|
1 /* |
|
2 * Copyright (c) 2007-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 the License "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 |
|
20 // INCLUDE FILES |
|
21 #include "cmmpacketservicemesshandler.h" |
|
22 #include "cmmnetmesshandler.h" |
|
23 #include "cmmmessagerouter.h" |
|
24 #include "cmmstaticutility.h" |
|
25 #include "tsylogger.h" |
|
26 |
|
27 #include <in_sock.h> |
|
28 #include <tisi.h> |
|
29 #include <ctsy/pluginapi/cmmdatapackage.h> |
|
30 #include <gpdsisi.h> |
|
31 #include <pcktcs.h> |
|
32 #include <gpds_sharedisi.h> |
|
33 #include <ctsy/serviceapi/gsmerror.h> |
|
34 |
|
35 #include "osttracedefinitions.h" |
|
36 #ifdef OST_TRACE_COMPILER_IN_USE |
|
37 #include "cmmpacketservicemesshandlertraces.h" |
|
38 #endif |
|
39 |
|
40 // EXTERNAL DATA STRUCTURES |
|
41 //None |
|
42 |
|
43 // EXTERNAL FUNCTION PROTOTYPES |
|
44 //None |
|
45 |
|
46 // CONSTANTS |
|
47 const TUint8 KSetAlwaysOnMode = 0x12; |
|
48 |
|
49 // MACROS |
|
50 //None |
|
51 |
|
52 // LOCAL CONSTANTS AND MACROS |
|
53 //None |
|
54 |
|
55 // MODULE DATA STRUCTURES |
|
56 //None |
|
57 |
|
58 // LOCAL FUNCTION PROTOTYPES |
|
59 //None |
|
60 |
|
61 // FORWARD DECLARATIONS |
|
62 //None |
|
63 |
|
64 // ==================== LOCAL FUNCTIONS ======================================= |
|
65 //None |
|
66 |
|
67 // ================= MEMBER FUNCTIONS ========================================= |
|
68 |
|
69 // ---------------------------------------------------------------------------- |
|
70 // CMmPacketServiceMessHandler::CMmPacketServiceMessHandler |
|
71 // C++ default constructor can NOT contain any code, that |
|
72 // might leave. |
|
73 // ---------------------------------------------------------------------------- |
|
74 // |
|
75 CMmPacketServiceMessHandler::CMmPacketServiceMessHandler() |
|
76 { |
|
77 |
|
78 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::C++ constructor"); |
|
79 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_CMMPACKETSERVICEMESSHANDLER, "CMmPacketServiceMessHandler::CMmPacketServiceMessHandler" ); |
|
80 } |
|
81 |
|
82 // ----------------------------------------------------------------------------- |
|
83 // CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler |
|
84 // Destructor, deletes all allocated resources. |
|
85 // ----------------------------------------------------------------------------- |
|
86 // |
|
87 CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler() |
|
88 { |
|
89 |
|
90 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler.\n" ); |
|
91 OstTrace0( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_CMMPACKETSERVICEMESSHANDLER, "CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler" ); |
|
92 |
|
93 // Delete iPacketMesshandlerContextList object |
|
94 if ( iPacketMesshandlerContextList ) |
|
95 { |
|
96 delete iPacketMesshandlerContextList; |
|
97 } |
|
98 } |
|
99 |
|
100 |
|
101 // ---------------------------------------------------------------------------- |
|
102 // CMmPacketServiceMessHandler::NewL |
|
103 // Two-phased constructor. |
|
104 // ---------------------------------------------------------------------------- |
|
105 // |
|
106 CMmPacketServiceMessHandler* CMmPacketServiceMessHandler::NewL( |
|
107 CMmPhoNetSender* aPhoNetSender, |
|
108 CMmPhoNetReceiver* aPhoNetReceiver, |
|
109 CMmMessageRouter* aMessageRouter ) |
|
110 { |
|
111 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NewL" ); |
|
112 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NEWL, "CMmPacketServiceMessHandler::NewL" ); |
|
113 |
|
114 CMmPacketServiceMessHandler* packetServiceMessHandler = |
|
115 new( ELeave ) CMmPacketServiceMessHandler(); |
|
116 |
|
117 CleanupStack::PushL( packetServiceMessHandler ); |
|
118 packetServiceMessHandler->iPhoNetSender = aPhoNetSender; |
|
119 packetServiceMessHandler->iMessageRouter = aMessageRouter; |
|
120 |
|
121 packetServiceMessHandler->ConstructL(); |
|
122 |
|
123 aPhoNetReceiver->RegisterL( |
|
124 packetServiceMessHandler, |
|
125 PN_GPDS ); |
|
126 aPhoNetReceiver->RegisterL( |
|
127 packetServiceMessHandler, |
|
128 PN_MODEM_NETWORK, |
|
129 NET_MODEM_REG_STATUS_GET_RESP ); |
|
130 aPhoNetReceiver->RegisterL( |
|
131 packetServiceMessHandler, |
|
132 PN_MODEM_NETWORK, |
|
133 NET_MODEM_REG_STATUS_IND ); |
|
134 aPhoNetReceiver->RegisterL( |
|
135 packetServiceMessHandler, |
|
136 PN_MODEM_NETWORK, |
|
137 NET_RAT_IND ); |
|
138 aPhoNetReceiver->RegisterL( |
|
139 packetServiceMessHandler, |
|
140 PN_MODEM_NETWORK, |
|
141 NET_RAT_RESP ); |
|
142 aPhoNetReceiver->RegisterL( |
|
143 packetServiceMessHandler, |
|
144 PN_MODEM_NETWORK, |
|
145 NET_RADIO_INFO_IND ); |
|
146 |
|
147 CleanupStack::Pop( packetServiceMessHandler ); |
|
148 |
|
149 return packetServiceMessHandler; |
|
150 } |
|
151 |
|
152 // ---------------------------------------------------------------------------- |
|
153 // CMmPacketServiceMessHandler::ConstructL |
|
154 // Symbian 2nd phase constructor can leave. |
|
155 // ---------------------------------------------------------------------------- |
|
156 // |
|
157 void CMmPacketServiceMessHandler::ConstructL() |
|
158 { |
|
159 |
|
160 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::ConstructL"); |
|
161 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_CONSTRUCTL, "CMmPacketServiceMessHandler::ConstructL" ); |
|
162 |
|
163 iAlwaysOnMode = RMmCustomAPI::EAlwaysModeNeither; |
|
164 |
|
165 iPacketMesshandlerContextList = CMmPacketContextMesshandlerList::NewL(); |
|
166 } |
|
167 |
|
168 // ---------------------------------------------------------------------------- |
|
169 // CMmPacketServiceMessHandler::ExtFuncL |
|
170 // Entry point for messages received from Symbian OS layer (Message manager) |
|
171 // ---------------------------------------------------------------------------- |
|
172 // |
|
173 TInt CMmPacketServiceMessHandler::ExtFuncL( |
|
174 TInt aIpc, |
|
175 const CMmDataPackage* aDataPackage ) |
|
176 { |
|
177 |
|
178 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::ExtFuncL. IPC: %d", aIpc ); |
|
179 OstTrace1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_EXTFUNCL, "CMmPacketServiceMessHandler::ExtFuncL;aIpc=%d", aIpc ); |
|
180 |
|
181 TInt ret( KErrNotSupported ); |
|
182 CMmDataPackage dataPackage; |
|
183 |
|
184 switch ( aIpc ) |
|
185 { |
|
186 case EPacketNotifyContextAdded: |
|
187 { |
|
188 // DO NOTHING |
|
189 break; |
|
190 } |
|
191 case EPacketAttach: |
|
192 { |
|
193 ret = GpdsAttachReq(); |
|
194 break; |
|
195 } |
|
196 case EPacketDetach: |
|
197 { |
|
198 ret = GpdsDetachReq(); |
|
199 break; |
|
200 } |
|
201 case EPacketRejectActivationRequest: |
|
202 { |
|
203 ret = GpdsContextNwiActRejectReq(); |
|
204 break; |
|
205 } |
|
206 case EPacketGetNtwkRegStatus: |
|
207 { |
|
208 ret = NetModemRegStatusGetReq(); |
|
209 break; |
|
210 } |
|
211 case EPacketSetPrefBearer: |
|
212 { |
|
213 ret = SetPreferredBearer( *aDataPackage ); |
|
214 break; |
|
215 } |
|
216 case EPacketSetAttachMode: |
|
217 { |
|
218 RPacketService::TAttachMode* dataPtr = NULL; |
|
219 aDataPackage->UnPackData ( &dataPtr ); |
|
220 ret = SetAttachMode( dataPtr ); |
|
221 break; |
|
222 } |
|
223 case EPacketGetAttachMode: |
|
224 { |
|
225 TBool calledOnInitPhase; |
|
226 aDataPackage->UnPackData( calledOnInitPhase ); |
|
227 ret = GpdsConfigurationInfoReq( calledOnInitPhase ); |
|
228 break; |
|
229 } |
|
230 case EPacketSetDefaultContextParams: |
|
231 { |
|
232 ret = SetDefaultContextParams( *aDataPackage ); |
|
233 break; |
|
234 } |
|
235 case EPacketNotifyStatusChange: |
|
236 { |
|
237 ret = GpdsStatusReq(); |
|
238 break; |
|
239 } |
|
240 case EPacketInitProxiesIPC: |
|
241 { |
|
242 ret = KMmPacketContextProxy1_DOS; |
|
243 break; |
|
244 } |
|
245 case ECustomSetAlwaysOnMode: |
|
246 { |
|
247 RMmCustomAPI::TSetAlwaysOnMode alwaysOnMode; |
|
248 aDataPackage->UnPackData( alwaysOnMode ); |
|
249 |
|
250 ret = GpdsConfigureReq( |
|
251 KSetAlwaysOnMode, |
|
252 GPDS_ATTACH_MODE_DEFAULT, |
|
253 GPDS_MT_ACT_MODE_ACCEPT, |
|
254 GPDS_CLASSC_MODE_DEFAULT, |
|
255 alwaysOnMode ); |
|
256 break; |
|
257 } |
|
258 default: |
|
259 { |
|
260 |
|
261 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::ExtFuncL - Unknown IPC: %d", aIpc); |
|
262 OstTrace1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_EXTFUNCL, "CMmPacketServiceMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc ); |
|
263 break; |
|
264 } |
|
265 } |
|
266 |
|
267 return ret; |
|
268 } |
|
269 |
|
270 // ---------------------------------------------------------------------------- |
|
271 // CMmPacketServiceMessHandler::ReceiveMessageL |
|
272 // Entry point for messages received from Domestic OS. |
|
273 // Switches the message to the correct method. |
|
274 // ----------------------------------------------------------------------------- |
|
275 // |
|
276 void CMmPacketServiceMessHandler::ReceiveMessageL( |
|
277 const TIsiReceiveC &aIsiMessage ) |
|
278 { |
|
279 TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) ); |
|
280 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ); |
|
281 |
|
282 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::ReceiveMessageL. resource:%d, msgId:%d", resource, messageId); |
|
283 OstTraceExt2( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_RECEIVEMESSAGEL, "CMmPacketServiceMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId ); |
|
284 |
|
285 switch ( resource ) |
|
286 { |
|
287 case PN_MODEM_NETWORK: |
|
288 { |
|
289 switch ( messageId ) |
|
290 { |
|
291 case NET_MODEM_REG_STATUS_GET_RESP: |
|
292 case NET_MODEM_REG_STATUS_IND: |
|
293 { |
|
294 NetModemRegStatusGetRespOrInd( aIsiMessage ); |
|
295 break; |
|
296 } |
|
297 case NET_RAT_IND: |
|
298 case NET_RAT_RESP: |
|
299 { |
|
300 NetRatIndOrResp( aIsiMessage ); |
|
301 break; |
|
302 } |
|
303 case NET_RADIO_INFO_IND: |
|
304 { |
|
305 NetRadioInfoInd( aIsiMessage ); |
|
306 break; |
|
307 } |
|
308 default: |
|
309 { |
|
310 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::ReceiveMessageL. default in case PN_MODEM_NETWORK"); |
|
311 OstTrace0( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_RECEIVEMESSAGEL, "CMmPacketServiceMessHandler::ReceiveMessageL, default in case PN_MODEM_NETWORK" ); |
|
312 break; |
|
313 } |
|
314 } |
|
315 break; |
|
316 } |
|
317 case PN_GPDS: |
|
318 { |
|
319 switch ( messageId ) |
|
320 { |
|
321 case GPDS_CONTEXT_ID_CREATE_IND: |
|
322 { |
|
323 GpdsContextIdCreateInd( aIsiMessage ); |
|
324 break; |
|
325 } |
|
326 case GPDS_CONFIGURATION_INFO_RESP: |
|
327 { |
|
328 GpdsConfigurationInfoResp( aIsiMessage ); |
|
329 break; |
|
330 } |
|
331 case GPDS_CONFIGURATION_INFO_IND: |
|
332 { |
|
333 GpdsConfigurationInfoInd( aIsiMessage ); |
|
334 break; |
|
335 } |
|
336 case GPDS_TRANSFER_STATUS_IND: |
|
337 { |
|
338 GpdsTransferStatusInd( aIsiMessage ); |
|
339 break; |
|
340 } |
|
341 case GPDS_CONFIGURE_RESP: |
|
342 { |
|
343 GpdsConfigureResp( aIsiMessage ); |
|
344 break; |
|
345 } |
|
346 case GPDS_STATUS_RESP: |
|
347 { |
|
348 GpdsStatusResp( aIsiMessage ); |
|
349 break; |
|
350 } |
|
351 case GPDS_ATTACH_RESP: |
|
352 { |
|
353 GpdsAttachResp( aIsiMessage ); |
|
354 break; |
|
355 } |
|
356 case GPDS_ATTACH_IND: |
|
357 { |
|
358 GpdsAttachInd(); |
|
359 break; |
|
360 } |
|
361 case GPDS_DETACH_RESP: |
|
362 { |
|
363 GpdsDetachResp( aIsiMessage ); |
|
364 break; |
|
365 } |
|
366 case GPDS_DETACH_IND: |
|
367 { |
|
368 GpdsDetachInd(); |
|
369 break; |
|
370 } |
|
371 case GPDS_CONTEXT_NWI_ACT_REQUEST_IND: |
|
372 { |
|
373 GpdsContextNwiActRequestInd( aIsiMessage ); |
|
374 break; |
|
375 } |
|
376 case GPDS_CONTEXT_NWI_ACT_REJECT_RESP: |
|
377 { |
|
378 GpdsContextNwiActRejectResp( aIsiMessage ); |
|
379 break; |
|
380 } |
|
381 case GPDS_CONTEXT_CONFIGURE_RESP: |
|
382 { |
|
383 GpdsContextConfigureResp( aIsiMessage ); |
|
384 break; |
|
385 } |
|
386 default: |
|
387 { |
|
388 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SpecificPacketServiceMessageReceived: KErrNotFound"); |
|
389 OstTrace0( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_RECEIVEMESSAGEL, "CMmPacketServiceMessHandler::ReceiveMessageL, KErrNotFound" ); |
|
390 break; |
|
391 } |
|
392 } |
|
393 break; |
|
394 } |
|
395 default: |
|
396 { |
|
397 // No appropriate handler methods for ISI-message found. |
|
398 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SpecificPacketServiceMessageReceived no handler for the message id"); |
|
399 OstTrace0( TRACE_NORMAL, DUP3_CMMPACKETSERVICEMESSHANDLER_RECEIVEMESSAGEL, "CMmPacketServiceMessHandler::ReceiveMessageL, SpecificPacketServiceMessageReceived no handler for the message id" ); |
|
400 // server not known |
|
401 break; |
|
402 } |
|
403 } |
|
404 } |
|
405 |
|
406 // ---------------------------------------------------------------------------- |
|
407 // CMmPacketServiceMessHandler::GpdsStatusReq |
|
408 // Constructs GPDS_STATUS_REQ ISI message and sends it to Phonet |
|
409 // ---------------------------------------------------------------------------- |
|
410 // |
|
411 TInt CMmPacketServiceMessHandler::GpdsStatusReq() const |
|
412 { |
|
413 |
|
414 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsStatusReq.\n" ); |
|
415 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSSTATUSREQ, "CMmPacketServiceMessHandler::GpdsStatusReq" ); |
|
416 |
|
417 // Append data for ISI message |
|
418 TBuf8<KBuffSizeOneByte> data; |
|
419 |
|
420 // Message sent via Phonet |
|
421 // Transaction id ( 0xDD - KDummyTrIdDD ) is not needed to store, dummy is enough |
|
422 // create gpds status request |
|
423 return iPhoNetSender->Send( PN_GPDS, KDummyTrIdDD, GPDS_STATUS_REQ, data ); |
|
424 } |
|
425 |
|
426 // ---------------------------------------------------------------------------- |
|
427 // CMmPacketServiceMessHandler::GpdsStatusResp |
|
428 // Breaks a GPDS_STATUS_RESP ISI message |
|
429 // ---------------------------------------------------------------------------- |
|
430 // |
|
431 void CMmPacketServiceMessHandler::GpdsStatusResp( |
|
432 const TIsiReceiveC& aIsiMessage ) |
|
433 { |
|
434 |
|
435 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsStatusResp.\n" ); |
|
436 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSSTATUSRESP, "CMmPacketServiceMessHandler::GpdsStatusResp" ); |
|
437 |
|
438 const TUint8 attachStatus( aIsiMessage.Get8bit( |
|
439 ISI_HEADER_SIZE + GPDS_STATUS_RESP_OFFSET_ATTACHSTATUS ) ); |
|
440 const TUint8 transfStatus( aIsiMessage.Get8bit( |
|
441 ISI_HEADER_SIZE + GPDS_STATUS_RESP_OFFSET_TRANSFERSTATUS ) ); |
|
442 |
|
443 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::GpdsStatusResp.\n \t Attach Status:%d\n\t Transfer Status:%d\n", attachStatus, transfStatus ); |
|
444 OstTraceExt2( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSSTATUSRESP, "CMmPacketServiceMessHandler::GpdsStatusResp;attachStatus=%hhu;transfStatus=%hhu", attachStatus, transfStatus ); |
|
445 |
|
446 CompleteGpdsStatusRequest( attachStatus, transfStatus ); |
|
447 } |
|
448 |
|
449 // ---------------------------------------------------------------------------- |
|
450 // CMmPacketServiceMessHandler::GpdsAttachReq |
|
451 // Constructs GPDS_ATTACH_REQ ISI message and sends it to Phonet. |
|
452 // ---------------------------------------------------------------------------- |
|
453 // |
|
454 TInt CMmPacketServiceMessHandler::GpdsAttachReq() const |
|
455 { |
|
456 |
|
457 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachReq.\n" ); |
|
458 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSATTACHREQ, "CMmPacketServiceMessHandler::GpdsAttachReq" ); |
|
459 |
|
460 // Append data for ISI message |
|
461 TBuf8<1> data; |
|
462 data.Append( GPDS_FOLLOW_OFF ); |
|
463 |
|
464 // Message sent via Phonet |
|
465 return iPhoNetSender->Send( |
|
466 PN_GPDS, GPDS_ATTACH_REQ, GPDS_ATTACH_REQ, data ); |
|
467 } |
|
468 |
|
469 // ---------------------------------------------------------------------------- |
|
470 // CMmPacketServiceMessHandler::GpdsAttachResp |
|
471 // Breaks a GPDS_ATTACH_RESP ISI message |
|
472 // ---------------------------------------------------------------------------- |
|
473 // |
|
474 void CMmPacketServiceMessHandler::GpdsAttachResp( |
|
475 const TIsiReceiveC& aIsiMessage ) const |
|
476 { |
|
477 |
|
478 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachResp.\n" ); |
|
479 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSATTACHRESP, "CMmPacketServiceMessHandler::GpdsAttachResp" ); |
|
480 |
|
481 if ( GPDS_ATTACH_REQ == aIsiMessage.Get8bit( |
|
482 ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_UTID ) ) |
|
483 { |
|
484 const TUint8 status( aIsiMessage.Get8bit( |
|
485 ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_STATUS ) ); |
|
486 const TUint8 cause( aIsiMessage.Get8bit( |
|
487 ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_CAUSE ) ); |
|
488 TInt errorValue( KErrNone ); |
|
489 |
|
490 if ( GPDS_OK != status ) |
|
491 { |
|
492 // Map CS error code to EPOC error code |
|
493 errorValue = CMmStaticUtility::PacketDataCSCauseToEpocError( |
|
494 cause ); |
|
495 } |
|
496 //no else |
|
497 |
|
498 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::GpdsAttachResp.\n \t Status:%d\n\t Cause:%d\n", status, cause ); |
|
499 OstTraceExt2( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSATTACHRESP, "CMmPacketServiceMessHandler::GpdsAttachResp;status=%hhu;cause=%hhu", status, cause ); |
|
500 |
|
501 //Complete Attach |
|
502 iMessageRouter->Complete( |
|
503 EPacketAttach, |
|
504 errorValue ); |
|
505 } |
|
506 //no else |
|
507 } |
|
508 |
|
509 // ---------------------------------------------------------------------------- |
|
510 // CMmPacketServiceMessHandler::GpdsAttachInd |
|
511 // Breaks a GPDS_ATTACH_IND ISI message |
|
512 // ---------------------------------------------------------------------------- |
|
513 // |
|
514 void CMmPacketServiceMessHandler::GpdsAttachInd() const |
|
515 { |
|
516 |
|
517 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachInd.\n" ); |
|
518 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSATTACHIND, "CMmPacketServiceMessHandler::GpdsAttachInd" ); |
|
519 |
|
520 RPacketService::TStatus status( RPacketService::EStatusAttached ); |
|
521 TBool isResumed( EFalse ); |
|
522 |
|
523 CMmDataPackage data; |
|
524 data.PackData( &status, &isResumed ); |
|
525 |
|
526 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsAttachInd. Complete\n\t Status:%d\n", status ); |
|
527 |
|
528 iMessageRouter->Complete( |
|
529 EPacketNotifyStatusChange, |
|
530 &data, |
|
531 KErrNone ); |
|
532 } |
|
533 |
|
534 // ---------------------------------------------------------------------------- |
|
535 // CMmPacketServiceMessHandler::GpdsDetachReq |
|
536 // Constructs GPDS_DETACH_REQ ISI message and sends it to Phonet. |
|
537 // ---------------------------------------------------------------------------- |
|
538 // |
|
539 TInt CMmPacketServiceMessHandler::GpdsDetachReq() const |
|
540 { |
|
541 |
|
542 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsDetachReq.\n" ); |
|
543 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSDETACHREQ, "CMmPacketServiceMessHandler::GpdsDetachReq" ); |
|
544 |
|
545 // Create isi message |
|
546 TBuf8<SIZE_GPDS_DETACH_REQ + SIZE_GPDS_CONDITIONAL_DETACH_INFO> |
|
547 messageData; |
|
548 |
|
549 // Add filler |
|
550 messageData.Append( KGpdsPadding ); |
|
551 // Add number of subblocks (GPDS_CONDITIONAL_DETACH_INFO) |
|
552 TUint8 subBlockCount( 1 ); |
|
553 messageData.Append( subBlockCount ); |
|
554 |
|
555 // Add conditional detach info sub block |
|
556 TIsiSubBlock gpdsConditionalDetachinfoSb( |
|
557 messageData, |
|
558 GPDS_CONDITIONAL_DETACH_INFO, |
|
559 EIsiSubBlockTypeId8Len8 ); |
|
560 |
|
561 // Add fillers |
|
562 messageData.Append( KGpdsPadding ); |
|
563 messageData.Append( KGpdsPadding ); |
|
564 // Complete subblock |
|
565 gpdsConditionalDetachinfoSb.CompleteSubBlock(); |
|
566 |
|
567 // Message sent via Phonet |
|
568 return iPhoNetSender->Send( |
|
569 PN_GPDS, GPDS_DETACH_REQ, GPDS_DETACH_REQ, messageData ); |
|
570 } |
|
571 |
|
572 // ---------------------------------------------------------------------------- |
|
573 // CMmPacketServiceMessHandler::GpdsDetachResp |
|
574 // Breaks a GPDS_DETACH_RESP ISI message |
|
575 // ---------------------------------------------------------------------------- |
|
576 // |
|
577 void CMmPacketServiceMessHandler::GpdsDetachResp( |
|
578 const TIsiReceiveC& aIsiMessage ) const |
|
579 { |
|
580 |
|
581 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsDetachResp.\n" ); |
|
582 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSDETACHRESP, "CMmPacketServiceMessHandler::GpdsDetachResp" ); |
|
583 |
|
584 if ( GPDS_DETACH_REQ == aIsiMessage.Get8bit( |
|
585 ISI_HEADER_SIZE + GPDS_DETACH_RESP_OFFSET_UTID ) ) |
|
586 { |
|
587 TInt errorValue( KErrNone ); |
|
588 const TUint8 status( aIsiMessage.Get8bit( |
|
589 ISI_HEADER_SIZE + GPDS_DETACH_RESP_OFFSET_STATUS ) ); |
|
590 |
|
591 if ( GPDS_OK != status ) |
|
592 { |
|
593 // Error is network failure |
|
594 errorValue = CMmStaticUtility::EpocErrorCode( |
|
595 KErrGeneral, KErrGsmMMNetworkFailure ); |
|
596 } |
|
597 |
|
598 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsDetachResp.\n\t Status:%d\n", status ); |
|
599 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSDETACHRESP, "CMmPacketServiceMessHandler::GpdsDetachResp;status=%hhu", status ); |
|
600 |
|
601 //Complete |
|
602 iMessageRouter->Complete( |
|
603 EPacketDetach, |
|
604 errorValue ); |
|
605 } |
|
606 } |
|
607 |
|
608 // ---------------------------------------------------------------------------- |
|
609 // CMmPacketServiceMessHandler::GpdsDetachInd |
|
610 // Breaks a GPDS_DETACH_IND ISI message |
|
611 // ---------------------------------------------------------------------------- |
|
612 // |
|
613 void CMmPacketServiceMessHandler::GpdsDetachInd() const |
|
614 { |
|
615 |
|
616 // Params for completion |
|
617 RPacketService::TStatus status = RPacketService::EStatusUnattached; |
|
618 |
|
619 // is resumed from suspend |
|
620 TBool isResumed( EFalse ); |
|
621 |
|
622 CMmDataPackage data; |
|
623 data.PackData( &status, &isResumed ); |
|
624 |
|
625 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsDetachInd. Complete\n\t status:%d\n", status ); |
|
626 |
|
627 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSDETACHIND, "CMmPacketServiceMessHandler::GpdsDetachInd;status=%hhu", status ); |
|
628 iMessageRouter->Complete( |
|
629 EPacketNotifyStatusChange, |
|
630 &data, |
|
631 KErrNone ); |
|
632 } |
|
633 |
|
634 // ---------------------------------------------------------------------------- |
|
635 // CMmPacketServiceMessHandler::NetModemRegStatusGetReq |
|
636 // Constructs and sends NET_MODEM_REG_STATUS_GET_REQ ISI message. |
|
637 // ---------------------------------------------------------------------------- |
|
638 // |
|
639 TInt CMmPacketServiceMessHandler::NetModemRegStatusGetReq() const |
|
640 { |
|
641 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetReq" ); |
|
642 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETREQ, "CMmPacketServiceMessHandler::NetModemRegStatusGetReq" ); |
|
643 |
|
644 // Data buffer for transactionId and Message Id. |
|
645 TBuf8<2> data; |
|
646 data.Append( NET_MODEM_REG_STATUS_GET_REQ ); |
|
647 data.Append( NET_MODEM_REG_STATUS_GET_REQ ); |
|
648 |
|
649 TIsiSend isimsg( iPhoNetSender->SendBufferDes() ); |
|
650 isimsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_MODEM_NETWORK ); |
|
651 isimsg.CopyData( ISI_HEADER_SIZE, data ); |
|
652 |
|
653 return ( iPhoNetSender->Send( isimsg.Complete() ) ); |
|
654 } |
|
655 |
|
656 // ---------------------------------------------------------------------------- |
|
657 // CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd |
|
658 // Breaks an ISI message. NET_MODEM_REG_STATUS_GET_RESP or |
|
659 // NET_MODEM_REG_STATUS_IND -ISI message |
|
660 // ---------------------------------------------------------------------------- |
|
661 void CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd( |
|
662 const TIsiReceiveC &aIsiMessage ) |
|
663 { |
|
664 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd"); |
|
665 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd" ); |
|
666 |
|
667 TUint sbStartOffSet( 0 ); |
|
668 TInt ret( 0 ); |
|
669 TBool isNetModemRegStatusInd( NET_MODEM_REG_STATUS_IND == |
|
670 aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ); |
|
671 |
|
672 TUint8 regStatus( 0 ); |
|
673 ret = iMessageRouter->GetNetMessHandler()->ExtractNetworkRegistrationStatus( |
|
674 aIsiMessage, |
|
675 regStatus |
|
676 ); |
|
677 |
|
678 if ( KErrNone == ret ) |
|
679 { |
|
680 if ( !isNetModemRegStatusInd ) |
|
681 { |
|
682 CMmDataPackage data; |
|
683 const TUint8 successCode( aIsiMessage.Get8bit( |
|
684 ISI_HEADER_SIZE + |
|
685 NET_MODEM_REG_STATUS_GET_RESP_OFFSET_SUCCESSCODE ) ); |
|
686 |
|
687 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - NetModemRegStatusGetResp, Registration Status:%d Success Code:%d", regStatus, successCode); |
|
688 OstTraceExt2( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - NetModemRegStatusGetResp, Registration Status=%hhu Success Code=%hhu", regStatus, successCode ); |
|
689 |
|
690 // Map registration status mapping |
|
691 RPacketService::TRegistrationStatus regStatusClient( |
|
692 MapNtwkRegStatus( regStatus, successCode ) ); |
|
693 |
|
694 data.PackData( ®StatusClient ); |
|
695 |
|
696 // Complete |
|
697 iMessageRouter->Complete( |
|
698 EPacketGetNtwkRegStatus, |
|
699 &data, |
|
700 KErrNone ); |
|
701 } |
|
702 else |
|
703 { |
|
704 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - NetModemRegStatusInd, Registration Status:%d", regStatus); |
|
705 OstTraceExt1( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - NetModemRegStatusInd, Registration Status=%hhu", regStatus ); |
|
706 |
|
707 CMmDataPackage data; |
|
708 |
|
709 // Map Status |
|
710 RPacketService::TRegistrationStatus regstatus( |
|
711 MapNtwkRegStatus( regStatus ) ); |
|
712 |
|
713 // Pack data for completion |
|
714 data.PackData( ®status ); |
|
715 |
|
716 // Complete |
|
717 iMessageRouter->Complete( |
|
718 EPacketNotifyChangeOfNtwkRegStatus, |
|
719 &data, |
|
720 KErrNone ); |
|
721 } |
|
722 } |
|
723 // No else |
|
724 |
|
725 sbStartOffSet = 0; |
|
726 |
|
727 // NET_MODEM_GSM_REG_INFO sub block |
|
728 if( isNetModemRegStatusInd ) |
|
729 { |
|
730 ret = aIsiMessage.FindSubBlockOffsetById( |
|
731 ISI_HEADER_SIZE + SIZE_NET_MODEM_REG_STATUS_IND, |
|
732 NET_MODEM_GSM_REG_INFO, |
|
733 EIsiSubBlockTypeId8Len8, |
|
734 sbStartOffSet ); |
|
735 } |
|
736 else |
|
737 { |
|
738 ret = aIsiMessage.FindSubBlockOffsetById( |
|
739 ISI_HEADER_SIZE + SIZE_NET_MODEM_REG_STATUS_GET_RESP, |
|
740 NET_MODEM_GSM_REG_INFO, |
|
741 EIsiSubBlockTypeId8Len8, |
|
742 sbStartOffSet ); |
|
743 } |
|
744 |
|
745 // Check that NET_MODEM_GSM_REG_INFO sub block is present |
|
746 if ( KErrNone == ret ) |
|
747 { |
|
748 // Get cs services |
|
749 const TBool csServices( aIsiMessage.Get8bit( |
|
750 sbStartOffSet + |
|
751 NET_MODEM_GSM_REG_INFO_OFFSET_CSSERVICES ) ); |
|
752 // Get gprs support in cell |
|
753 const TBool gprsSupported( aIsiMessage.Get8bit( |
|
754 sbStartOffSet + |
|
755 NET_MODEM_GSM_REG_INFO_OFFSET_GPRSSUPPORTINCELL ) ); |
|
756 // Get edge gprs support |
|
757 const TBool edgeGprsSupport( aIsiMessage.Get8bit( |
|
758 sbStartOffSet + |
|
759 NET_MODEM_GSM_REG_INFO_OFFSET_EGPRSSUPPORTINCELL ) ); |
|
760 |
|
761 const TBool dtmSupportInCell( aIsiMessage.Get8bit( |
|
762 sbStartOffSet + |
|
763 NET_MODEM_GSM_REG_INFO_OFFSET_DTMSUPPORTINCELL ) ); |
|
764 |
|
765 // save last DTM support |
|
766 iLastDtmSupportInCell = dtmSupportInCell; |
|
767 |
|
768 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - CS Services:%d GPRS support in cell:%d", csServices, gprsSupported); |
|
769 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - EdgeGprsSupport:%d", edgeGprsSupport); |
|
770 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - DtmSupport:%d", dtmSupportInCell); |
|
771 OstTraceExt2( TRACE_NORMAL, DUP3_CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - CS Services=%hhu GPRS support in cell=%hhu", csServices, gprsSupported ); |
|
772 OstTraceExt1( TRACE_NORMAL, DUP4_CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - EdgeGprsSupport=%hhu", edgeGprsSupport ); |
|
773 OstTraceExt1( TRACE_NORMAL, DUP5_CMMPACKETSERVICEMESSHANDLER_NETMODEMREGSTATUSGETRESPORIND, "CMmPacketServiceMessHandler::NetModemRegStatusGetRespOrInd - DtmSupport=%hhu", dtmSupportInCell ); |
|
774 |
|
775 // Complete notification to the active extension |
|
776 CompleteGsmRegistrationInfo( |
|
777 csServices, |
|
778 gprsSupported, |
|
779 edgeGprsSupport ); |
|
780 |
|
781 // Complete EPacketNotifyTransferCapsIPC |
|
782 CompletePacketNotifyTransferCaps( |
|
783 edgeGprsSupport ); |
|
784 |
|
785 // Get gprs network mode |
|
786 const TUint8 gprsNetworkMode( aIsiMessage.Get8bit( |
|
787 sbStartOffSet + |
|
788 NET_MODEM_GSM_REG_INFO_OFFSET_GPRSNETWORKMODE ) ); |
|
789 |
|
790 CompleteNotifyMSClassChange( gprsNetworkMode ); |
|
791 } |
|
792 } |
|
793 |
|
794 // ---------------------------------------------------------------------------- |
|
795 // CMmPacketServiceMessHandler::GpdsConfigureReq |
|
796 // Constructs and sends GPDS_CONFIGURE_REQ ISI message. |
|
797 // This request is used to set attach mode, class C mode or/and MT context |
|
798 // activation mode. Mode to be change should be set to other value than default |
|
799 // ( GPDS_ATTACH_MODE_DEFAULT, GPDS_MT_ACT_MODE_DEFAULT or GPDS_CLASSC_MODE_DEFAULT ) |
|
800 // ---------------------------------------------------------------------------- |
|
801 // |
|
802 TInt CMmPacketServiceMessHandler::GpdsConfigureReq( |
|
803 const TUint8 aTransactionId, |
|
804 const TUint8 aAttachMode, |
|
805 const TUint8 aMtContextActivationMode, |
|
806 const TUint8 aClassCMode, |
|
807 RMmCustomAPI::TSetAlwaysOnMode alwaysOnMode ) |
|
808 { |
|
809 |
|
810 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsConfigureReq.\n\t Attach Mode:%d\n", aAttachMode ); |
|
811 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGUREREQ, "CMmPacketServiceMessHandler::GpdsConfigureReq;aAttachMode=%hhu", aAttachMode ); |
|
812 |
|
813 TUint8 aAolContext = GPDS_AOL_CTX_NOT_ACTIVE; |
|
814 iAlwaysOnMode = alwaysOnMode; |
|
815 |
|
816 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::GpdsConfigureReq.\n \t Mt Context Activation Mode:%d\n\t Class C Mode:%d\n", aMtContextActivationMode, aClassCMode ); |
|
817 OstTraceExt2( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGUREREQ, "CMmPacketServiceMessHandler::GpdsConfigureReq;aMtContextActivationMode=%hhu;aClassCMode=%hhu", aMtContextActivationMode, aClassCMode ); |
|
818 |
|
819 switch ( iAlwaysOnMode ) |
|
820 { |
|
821 case RMmCustomAPI::EAlwaysModeHPLMN : |
|
822 { |
|
823 aAolContext = GPDS_AOL_CTX_HPLMN_ACTIVE; |
|
824 break; |
|
825 } |
|
826 case RMmCustomAPI::EAlwaysModeVPLMN: |
|
827 { |
|
828 aAolContext = GPDS_AOL_CTX_VPLMN_ACTIVE; |
|
829 break; |
|
830 } |
|
831 case RMmCustomAPI::EAlwaysModeBoth: |
|
832 { |
|
833 aAolContext = GPDS_AOL_CTX_ACTIVE; |
|
834 break; |
|
835 } |
|
836 case RMmCustomAPI::EAlwaysModeNeither: |
|
837 { |
|
838 aAolContext = GPDS_AOL_CTX_NOT_ACTIVE; |
|
839 break; |
|
840 } |
|
841 default: |
|
842 { |
|
843 |
|
844 TFLOGSTRING2("CMmPacketServiceMessHandler::GpdsConfigureReq.\n\t AOL Context Mode:%d\n", aAolContext); |
|
845 OstTraceExt1( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGUREREQ, "CMmPacketServiceMessHandler::GpdsConfigureReq;aAolContext=%hhu", aAolContext ); |
|
846 |
|
847 break; |
|
848 } |
|
849 } |
|
850 |
|
851 // Introduce data buffer for needed Gpds Configure Request data |
|
852 TBuf8<KBuffSizeFourBytes> data; |
|
853 data.Append( aAttachMode ); |
|
854 data.Append( aMtContextActivationMode ); |
|
855 data.Append( aClassCMode ); |
|
856 data.Append( aAolContext ); |
|
857 |
|
858 TUint8 transactionId( 0 ); |
|
859 |
|
860 // Create gpds configure request, 0xDC - KDummyTrIdDC is dummy for identifying calling method |
|
861 if ( KDummyTrIdDC == aTransactionId ) |
|
862 { |
|
863 transactionId = KDummyTrIdDC; |
|
864 } |
|
865 else if ( KSetAlwaysOnMode == aTransactionId ) |
|
866 { |
|
867 transactionId = KSetAlwaysOnMode; |
|
868 } |
|
869 else |
|
870 { |
|
871 transactionId = GPDS_CONFIGURE_REQ; |
|
872 } |
|
873 |
|
874 // Message sent via Phonet |
|
875 return iPhoNetSender->Send( |
|
876 PN_GPDS, transactionId, GPDS_CONFIGURE_REQ, data ); |
|
877 } |
|
878 |
|
879 // ---------------------------------------------------------------------------- |
|
880 // CMmPacketServiceMessHandler::GpdsConfigureResp |
|
881 // Breaks a GPDS_CONFIGURE_RESP ISI message. |
|
882 // ---------------------------------------------------------------------------- |
|
883 // |
|
884 void CMmPacketServiceMessHandler::GpdsConfigureResp( |
|
885 const TIsiReceiveC& aIsiMessage ) const |
|
886 { |
|
887 |
|
888 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsConfigureResp.\n" ); |
|
889 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURERESP, "CMmPacketServiceMessHandler::GpdsConfigureResp" ); |
|
890 |
|
891 TInt errorValue( KErrNone ); |
|
892 TBool called( EFalse ); |
|
893 |
|
894 const TUint8 transactionId( aIsiMessage.Get8bit( |
|
895 ISI_HEADER_SIZE + GPDS_CONFIGURE_RESP_OFFSET_UTID ) ); |
|
896 |
|
897 // Is this request called |
|
898 if ( GPDS_CONFIGURE_REQ == transactionId |
|
899 || KDummyTrIdDC == transactionId |
|
900 || KSetAlwaysOnMode == transactionId) |
|
901 // 0xDC is dummy for identifying calling method |
|
902 { |
|
903 called = ETrue; |
|
904 } |
|
905 //no else |
|
906 |
|
907 if ( called ) |
|
908 { |
|
909 // Get status |
|
910 const TUint8 status( aIsiMessage.Get8bit( |
|
911 ISI_HEADER_SIZE + GPDS_CONFIGURE_RESP_OFFSET_STATUS ) ); |
|
912 |
|
913 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsConfigureResp.\n\t Status:%d\n", status ); |
|
914 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURERESP, "CMmPacketServiceMessHandler::GpdsConfigureResp;status=%hhu", status ); |
|
915 |
|
916 if ( GPDS_CONFIGURE_REQ == transactionId ) |
|
917 { |
|
918 if ( GPDS_OK != status ) |
|
919 { |
|
920 errorValue = KErrGeneral; |
|
921 } |
|
922 //no else |
|
923 |
|
924 // Complete |
|
925 iMessageRouter->Complete( |
|
926 EPacketSetAttachMode, |
|
927 errorValue ); |
|
928 } |
|
929 // if called SetPrefBearer 0xDC is dummy for identifying calling method |
|
930 else if ( KDummyTrIdDC == transactionId ) |
|
931 { |
|
932 // error mapping |
|
933 if ( GPDS_OK != status ) |
|
934 { |
|
935 errorValue = KErrGeneral; |
|
936 } |
|
937 //no else |
|
938 |
|
939 // Complete |
|
940 iMessageRouter->Complete( |
|
941 EPacketSetPrefBearer, |
|
942 errorValue ); |
|
943 } |
|
944 |
|
945 else if ( KSetAlwaysOnMode == transactionId ) |
|
946 { |
|
947 |
|
948 if ( GPDS_OK != status ) |
|
949 { |
|
950 errorValue = KErrWrite; |
|
951 } |
|
952 |
|
953 // Complete |
|
954 iMessageRouter->Complete( |
|
955 ECustomSetAlwaysOnMode, |
|
956 errorValue ); |
|
957 } |
|
958 } |
|
959 } |
|
960 |
|
961 // ---------------------------------------------------------------------------- |
|
962 // CMmPacketServiceMessHandler::GpdsTransferStatusInd |
|
963 // Breaks a GPDS_TRANSFER_STATUS_IND ISI message |
|
964 // ---------------------------------------------------------------------------- |
|
965 // |
|
966 void CMmPacketServiceMessHandler::GpdsTransferStatusInd( |
|
967 const TIsiReceiveC& aIsiMessage ) |
|
968 { |
|
969 |
|
970 const TUint8 transferCause( aIsiMessage.Get8bit( |
|
971 ISI_HEADER_SIZE + GPDS_TRANSFER_STATUS_IND_OFFSET_TRANSFERCAUSE) ); |
|
972 |
|
973 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsTransferStatusInd.\n \t Transfer cause:%d\n", transferCause ); |
|
974 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSTRANSFERSTATUSIND, "CMmPacketServiceMessHandler::GpdsTransferStatusInd;transferCause=%hhu", transferCause ); |
|
975 |
|
976 CompleteTransferStatusIndication( transferCause ); |
|
977 } |
|
978 |
|
979 // ---------------------------------------------------------------------------- |
|
980 // CMmPacketServiceMessHandler::GpdsContextIdCreateInd |
|
981 // Breaks a GPDS_CONTEXT_ID_CREATE_IND ISI-message. |
|
982 // ---------------------------------------------------------------------------- |
|
983 // |
|
984 void CMmPacketServiceMessHandler::GpdsContextIdCreateInd( |
|
985 const TIsiReceiveC& aIsiMessage ) const |
|
986 { |
|
987 // Get context id from message |
|
988 const TUint8 contextId( aIsiMessage.Get8bit( |
|
989 ISI_HEADER_SIZE + GPDS_CONTEXT_ID_CREATE_IND_OFFSET_CID ) ); |
|
990 |
|
991 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsContextIdCreateInd.\n\t Context Id:%d\n", contextId ); |
|
992 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTIDCREATEIND, "CMmPacketServiceMessHandler::GpdsContextIdCreateInd;contextId=%hhu", contextId ); |
|
993 |
|
994 // initial variables |
|
995 CMmDataPackage data; |
|
996 TInfoName contextName; |
|
997 contextName.Zero(); |
|
998 |
|
999 // Get Contextname from CMmPacketMesshandlerContextList |
|
1000 TInt ret( iPacketMesshandlerContextList-> |
|
1001 GetContextNameByContextId( contextId, contextName ) ); |
|
1002 |
|
1003 // Dialup context |
|
1004 if( KErrArgument == ret ) |
|
1005 { |
|
1006 iPacketMesshandlerContextList->SetDialUpContextId( contextId ); |
|
1007 } |
|
1008 //no else |
|
1009 |
|
1010 data.PackData( &contextName, &ret ); |
|
1011 |
|
1012 iMessageRouter->Complete( |
|
1013 EPacketNotifyContextAdded, |
|
1014 &data, |
|
1015 KErrNone); |
|
1016 } |
|
1017 |
|
1018 // ---------------------------------------------------------------------------- |
|
1019 // CMmPacketServiceMessHandler::GpdsConfigurationInfoInd |
|
1020 // Breaks a GPDS_CONFIGURATION_INFO_IND ISI-message. |
|
1021 // ---------------------------------------------------------------------------- |
|
1022 // |
|
1023 void CMmPacketServiceMessHandler::GpdsConfigurationInfoInd( |
|
1024 const TIsiReceiveC& aIsiMessage ) const |
|
1025 { |
|
1026 |
|
1027 CMmDataPackage data; |
|
1028 |
|
1029 // Get class C mode |
|
1030 const TUint8 classC( aIsiMessage.Get8bit( |
|
1031 ISI_HEADER_SIZE + GPDS_CONFIGURATION_INFO_IND_OFFSET_CLASSCMODE) ); |
|
1032 |
|
1033 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsConfigurationInfoInd.\n\t Class C Mode:%d\n", classC ); |
|
1034 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURATIONINFOIND, "CMmPacketServiceMessHandler::GpdsConfigurationInfoInd;classC=%hhu", classC ); |
|
1035 |
|
1036 RPacketService::TPreferredBearer bearer( |
|
1037 RPacketService::EBearerPacketSwitched ); |
|
1038 |
|
1039 // set bearer |
|
1040 if ( GPDS_CLASSC_MODE_GSM == classC ) |
|
1041 { |
|
1042 bearer = RPacketService::EBearerCircuitSwitched; |
|
1043 } |
|
1044 |
|
1045 // Pack data |
|
1046 data.PackData( &bearer ); |
|
1047 |
|
1048 // Complete |
|
1049 iMessageRouter->Complete( |
|
1050 EPacketNotifyAttachModeChange, |
|
1051 &data, |
|
1052 KErrNone ); |
|
1053 } |
|
1054 |
|
1055 // ---------------------------------------------------------------------------- |
|
1056 // CMmPacketServiceMessHandler::GpdsContextNwiActRejectReq |
|
1057 // Creates GPDS_CONTEXT_NWI_ACT_REJECT_REQ ISI message. |
|
1058 // ---------------------------------------------------------------------------- |
|
1059 // |
|
1060 TInt CMmPacketServiceMessHandler::GpdsContextNwiActRejectReq() const |
|
1061 { |
|
1062 |
|
1063 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsContextNwiActRejectReq.\n" ); |
|
1064 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTNWIACTREJECTREQ, "CMmPacketServiceMessHandler::GpdsContextNwiActRejectReq" ); |
|
1065 |
|
1066 // Introduce data buffer for needed GpdsContextNwiActRejectReq data |
|
1067 // Needed length is 1 |
|
1068 TBuf8<1> data; |
|
1069 data.Append( GPDS_CAUSE_ACT_REJECT ); |
|
1070 |
|
1071 // Message sent via Phonet |
|
1072 return iPhoNetSender->Send( |
|
1073 PN_GPDS, |
|
1074 GPDS_CONTEXT_NWI_ACT_REJECT_REQ, |
|
1075 GPDS_CONTEXT_NWI_ACT_REJECT_REQ, |
|
1076 data ); |
|
1077 } |
|
1078 |
|
1079 // ---------------------------------------------------------------------------- |
|
1080 // CMmPacketServiceMessHandler::GpdsContextNwiActRejectResp |
|
1081 // Breaks a GPDS_CONTEXT_NWI_ACT_REJECT_RESP ISI-message. |
|
1082 // ---------------------------------------------------------------------------- |
|
1083 // |
|
1084 void CMmPacketServiceMessHandler::GpdsContextNwiActRejectResp( |
|
1085 const TIsiReceiveC& /*aIsiMessage*/) const |
|
1086 { |
|
1087 |
|
1088 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsContextNwiActRejectResp.\n" ); |
|
1089 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTNWIACTREJECTRESP, "CMmPacketServiceMessHandler::GpdsContextNwiActRejectResp" ); |
|
1090 |
|
1091 iMessageRouter->Complete( |
|
1092 EPacketRejectActivationRequest, |
|
1093 KErrNone ); |
|
1094 } |
|
1095 |
|
1096 // ---------------------------------------------------------------------------- |
|
1097 // CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd |
|
1098 // Breaks a GPDS_CONTEXT_NWI_ACT_REQUEST_IND ISI-message. |
|
1099 // ---------------------------------------------------------------------------- |
|
1100 // |
|
1101 void CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd( |
|
1102 const TIsiReceiveC& aIsiMessage ) |
|
1103 { |
|
1104 |
|
1105 RPacketContext::TContextConfigGPRS completeNotifyContextActivationReq; |
|
1106 // DataPackage |
|
1107 CMmDataPackage data; |
|
1108 |
|
1109 // Read pdp type from isi message |
|
1110 const TUint8 pdpType( aIsiMessage.Get8bit( |
|
1111 ISI_HEADER_SIZE + GPDS_CONTEXT_NWI_ACT_REQUEST_IND_OFFSET_PDPTYPE ) ); |
|
1112 |
|
1113 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd. PdpType:%d", pdpType ); |
|
1114 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTNWIACTREQUESTIND, "CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd;pdpType=%hhu", pdpType ); |
|
1115 |
|
1116 TPtrC8 pdpAddress; |
|
1117 TPtrC8 accessPointName; |
|
1118 TUint sbStartOffSet( 0 ); |
|
1119 |
|
1120 // GPDS_PDP_ADDRESS_INFO sub block |
|
1121 TInt retValue ( aIsiMessage.FindSubBlockOffsetById( |
|
1122 ISI_HEADER_SIZE + SIZE_GPDS_CONTEXT_NWI_ACT_REQUEST_IND, |
|
1123 GPDS_PDP_ADDRESS_INFO, |
|
1124 EIsiSubBlockTypeId8Len8, |
|
1125 sbStartOffSet ) ); |
|
1126 |
|
1127 if ( KErrNone == retValue ) |
|
1128 { |
|
1129 TUint8 addressLen( aIsiMessage.Get8bit( |
|
1130 sbStartOffSet + GPDS_PDP_ADDRESS_INFO_OFFSET_ADDRLENGTH ) ); |
|
1131 // Read pdp address from GPDS_PDP_ADDRESS_INFO sub block |
|
1132 pdpAddress.Set( aIsiMessage.GetData( |
|
1133 sbStartOffSet + GPDS_PDP_ADDRESS_INFO_OFFSET_ADDRESS, |
|
1134 addressLen ) ); |
|
1135 } |
|
1136 //no else |
|
1137 |
|
1138 if ( 0 < pdpAddress.Length() ) |
|
1139 { |
|
1140 CMmStaticUtility::ConvertIPAddressToClient( |
|
1141 pdpAddress, |
|
1142 completeNotifyContextActivationReq.iPdpAddress ); |
|
1143 } |
|
1144 //no else |
|
1145 |
|
1146 // GPDS_APN_INFO sub block |
|
1147 retValue = aIsiMessage.FindSubBlockOffsetById( |
|
1148 ISI_HEADER_SIZE + SIZE_GPDS_CONTEXT_NWI_ACT_REQUEST_IND, |
|
1149 GPDS_APN_INFO, |
|
1150 EIsiSubBlockTypeId8Len8, |
|
1151 sbStartOffSet ); |
|
1152 |
|
1153 if ( KErrNone == retValue ) |
|
1154 { |
|
1155 TUint8 apnSize( aIsiMessage.Get8bit( |
|
1156 sbStartOffSet + GPDS_APN_INFO_OFFSET_ADDRLENGTH ) ); |
|
1157 // Read access point name from GPDS_APN_INFO sub block |
|
1158 accessPointName.Set( aIsiMessage.GetData( |
|
1159 sbStartOffSet + GPDS_APN_INFO_OFFSET_APNNAME, apnSize ) ); |
|
1160 } |
|
1161 //no else |
|
1162 |
|
1163 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd.\n \t Pdp Type:%d\n", pdpType ); |
|
1164 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTNWIACTREQUESTIND, "CMmPacketServiceMessHandler::GpdsContextNwiActRequestInd;pdpType=%hhu", pdpType ); |
|
1165 |
|
1166 // Map server pdp type to client pdp type |
|
1167 CMmStaticUtility::MapPdpTypeToClient( |
|
1168 completeNotifyContextActivationReq.iPdpType, pdpType ); |
|
1169 |
|
1170 // Copy aAccessPointName from TDesC8& to RPacketContext::TGSNAddress |
|
1171 completeNotifyContextActivationReq.iAccessPointName.Copy( |
|
1172 accessPointName ); |
|
1173 |
|
1174 // Packdata for completion |
|
1175 data.PackData( &completeNotifyContextActivationReq ); |
|
1176 |
|
1177 // Complete indication |
|
1178 iMessageRouter->Complete( |
|
1179 EPacketNotifyContextActivationRequested, |
|
1180 &data, |
|
1181 KErrNone ); |
|
1182 } |
|
1183 |
|
1184 // ---------------------------------------------------------------------------- |
|
1185 // CMmPacketServiceMessHandler::GpdsConfigurationInfoReq |
|
1186 // Constructs and sends GPDS_CONFIGURATION_INFO_REQ ISI message. |
|
1187 // ---------------------------------------------------------------------------- |
|
1188 // |
|
1189 TInt CMmPacketServiceMessHandler::GpdsConfigurationInfoReq( |
|
1190 TBool aCalledOnInitPhase ) const |
|
1191 { |
|
1192 |
|
1193 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsConfigurationInfoReq.\n\t" ); |
|
1194 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURATIONINFOREQ, "CMmPacketServiceMessHandler::GpdsConfigurationInfoReq" ); |
|
1195 |
|
1196 TBuf8<1> data; |
|
1197 TUint8 transactionId( 0 ); |
|
1198 |
|
1199 // Create gpds configuration info request |
|
1200 if ( aCalledOnInitPhase ) |
|
1201 { |
|
1202 //0xDF -KDummyTrIdDF is dummy transaction id |
|
1203 transactionId = KDummyTrIdDF; |
|
1204 } |
|
1205 else |
|
1206 { |
|
1207 transactionId = GPDS_CONFIGURATION_INFO_REQ; |
|
1208 } |
|
1209 |
|
1210 // Message sent via Phonet |
|
1211 return iPhoNetSender->Send( |
|
1212 PN_GPDS, transactionId, GPDS_CONFIGURATION_INFO_REQ, data ); |
|
1213 } |
|
1214 |
|
1215 // ---------------------------------------------------------------------------- |
|
1216 // CMmPacketServiceMessHandler::GpdsConfigurationInfoResp |
|
1217 // Breaks a GPDS_CONFIGURATION_INFO_RERESP ISI-message. |
|
1218 // ---------------------------------------------------------------------------- |
|
1219 // |
|
1220 void CMmPacketServiceMessHandler::GpdsConfigurationInfoResp( |
|
1221 const TIsiReceiveC& aIsiMessage ) const |
|
1222 { |
|
1223 |
|
1224 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsConfigurationInfoResp.\n\t" ); |
|
1225 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURATIONINFORESP, "CMmPacketServiceMessHandler::GpdsConfigurationInfoResp" ); |
|
1226 |
|
1227 CMmDataPackage data; |
|
1228 TBool ret( EFalse ); |
|
1229 |
|
1230 // Is this request called |
|
1231 if ( GPDS_CONFIGURATION_INFO_REQ == aIsiMessage.Get8bit( |
|
1232 ISI_HEADER_SIZE + GPDS_CONFIGURATION_INFO_RESP_OFFSET_UTID ) ) |
|
1233 { |
|
1234 ret = ETrue; |
|
1235 } |
|
1236 //no else |
|
1237 |
|
1238 if ( ret ) |
|
1239 { |
|
1240 // Get attach mode |
|
1241 const TUint8 attachMode( aIsiMessage.Get8bit( |
|
1242 ISI_HEADER_SIZE + GPDS_CONFIGURATION_INFO_RESP_OFFSET_ATTACHMODE ) ); |
|
1243 |
|
1244 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::GpdsConfigurationInfoResp.\n\t Attach mode:%d\n", attachMode ); |
|
1245 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_GPDSCONFIGURATIONINFORESP, "CMmPacketServiceMessHandler::GpdsConfigurationInfoResp;attachMode=%hhu", attachMode ); |
|
1246 |
|
1247 RPacketService::TAttachMode attachModeForCompletion( |
|
1248 RPacketService::EAttachWhenNeeded ); |
|
1249 |
|
1250 if ( GPDS_ATTACH_MODE_AUTOMATIC == attachMode ) |
|
1251 { |
|
1252 attachModeForCompletion = RPacketService::EAttachWhenPossible; |
|
1253 } |
|
1254 //no else |
|
1255 |
|
1256 data.PackData( &attachModeForCompletion ); |
|
1257 iMessageRouter->Complete( |
|
1258 EPacketGetAttachMode, |
|
1259 &data, |
|
1260 KErrNone ); |
|
1261 } |
|
1262 // If transaction id is 0xDF - KDummyTrIdDF, this is response to the request made during |
|
1263 // initialisation |
|
1264 else if ( KDummyTrIdDF == aIsiMessage.Get8bit( ISI_HEADER_SIZE + |
|
1265 GPDS_CONFIGURATION_INFO_RESP_OFFSET_UTID) ) |
|
1266 { |
|
1267 // Get class c mode |
|
1268 const TUint8 classCMode ( aIsiMessage.Get8bit( ISI_HEADER_SIZE + |
|
1269 GPDS_CONFIGURATION_INFO_RESP_OFFSET_CLASSCMODE ) ); |
|
1270 |
|
1271 RPacketService::TPreferredBearer bearer( |
|
1272 RPacketService::EBearerPacketSwitched ); |
|
1273 |
|
1274 if ( GPDS_CLASSC_MODE_GSM == classCMode ) |
|
1275 { |
|
1276 bearer = RPacketService::EBearerCircuitSwitched; |
|
1277 } |
|
1278 //no else |
|
1279 |
|
1280 // Pack data |
|
1281 data.PackData( &bearer ); |
|
1282 // Complete |
|
1283 iMessageRouter->Complete( |
|
1284 EPacketNotifyAttachModeChange, |
|
1285 &data, |
|
1286 KErrNone ); |
|
1287 } |
|
1288 //no else |
|
1289 } |
|
1290 |
|
1291 // ---------------------------------------------------------------------------- |
|
1292 // CMmPacketServiceMessHandler::GpdsContextConfigureResp |
|
1293 // Response for default dial-up context configuration. |
|
1294 // ---------------------------------------------------------------------------- |
|
1295 // |
|
1296 void CMmPacketServiceMessHandler::GpdsContextConfigureResp( |
|
1297 const TIsiReceiveC& aIsiMessage ) const |
|
1298 { |
|
1299 |
|
1300 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsContextConfigureResp.\n" ); |
|
1301 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTCONFIGURERESP, "CMmPacketServiceMessHandler::GpdsContextConfigureResp" ); |
|
1302 |
|
1303 TBool called( EFalse ); |
|
1304 |
|
1305 if ( GPDS_CONTEXT_CONFIGURE_REQ == aIsiMessage.Get8bit( |
|
1306 ISI_HEADER_SIZE + GPDS_CONTEXT_CONFIGURE_RESP_OFFSET_UTID ) ) |
|
1307 { |
|
1308 called = ETrue; |
|
1309 } |
|
1310 //no else |
|
1311 |
|
1312 if ( called ) |
|
1313 { |
|
1314 const TUint8 status ( aIsiMessage.Get8bit( |
|
1315 ISI_HEADER_SIZE + GPDS_CONTEXT_CONFIGURE_RESP_OFFSET_STATUS ) ); |
|
1316 |
|
1317 TInt errorCause ( KErrGeneral ); |
|
1318 |
|
1319 if ( GPDS_OK == status ) |
|
1320 { |
|
1321 errorCause = KErrNone; |
|
1322 } |
|
1323 //no else |
|
1324 |
|
1325 iMessageRouter->Complete( |
|
1326 EPacketSetDefaultContextParams, |
|
1327 errorCause ); |
|
1328 } |
|
1329 } |
|
1330 |
|
1331 // ---------------------------------------------------------------------------- |
|
1332 // CMmPacketServiceMessHandler::GpdsContextConfigureReq |
|
1333 // Request for default dial-up context configuration. |
|
1334 // ---------------------------------------------------------------------------- |
|
1335 // |
|
1336 TInt CMmPacketServiceMessHandler::GpdsContextConfigureReq( |
|
1337 TUint8 aDataCompression, |
|
1338 TUint8 aHeaderCompression, |
|
1339 TBuf8<KAccessPointBuffer256> aAccessPointName, |
|
1340 TUint8 aPdpType ) |
|
1341 { |
|
1342 |
|
1343 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsContextConfigureReq.\n" ); |
|
1344 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GPDSCONTEXTCONFIGUREREQ, "CMmPacketServiceMessHandler::GpdsContextConfigureReq" ); |
|
1345 |
|
1346 // Append data for ISI message |
|
1347 TBuf8<SIZE_GPDS_CONTEXT_CONFIGURE_REQ + SIZE_GPDS_COMP_INFO + |
|
1348 SIZE_GPDS_APN_INFO + GPDS_MAX_APN_STRING_SIZE + |
|
1349 SIZE_GPDS_SHARED_RADIO_ACTIVITY_REQ_INFO> messageData; |
|
1350 |
|
1351 messageData.Append( GPDS_CID_ALL ); |
|
1352 messageData.Append( aPdpType ); |
|
1353 messageData.Append( GPDS_CONT_TYPE_NORMAL ); |
|
1354 messageData.Append( KGpdsPadding ); //primary CID |
|
1355 messageData.Append( KGpdsPadding ); //filler |
|
1356 // number of subblocks |
|
1357 // GPDS_APN_INFO, GPDS_COM_INFO and GPDS_SHARED_RADIO_ACTIVITY_REQ_INFO |
|
1358 TUint8 subBlockCount( 3 ); |
|
1359 messageData.Append( subBlockCount ); |
|
1360 |
|
1361 // Set the APN info |
|
1362 TInt apnLength( aAccessPointName.Length() ); |
|
1363 |
|
1364 // Add GPDS_APN_INFO subblock |
|
1365 TIsiSubBlock gpdsApnInfoSb( |
|
1366 messageData, |
|
1367 GPDS_APN_INFO, |
|
1368 EIsiSubBlockTypeId8Len8 ); |
|
1369 |
|
1370 messageData.Append( static_cast<TUint8>( apnLength ) ); |
|
1371 messageData.Append( aAccessPointName ); |
|
1372 gpdsApnInfoSb.CompleteSubBlock(); |
|
1373 |
|
1374 // Add GPDS_COMP_INFO subblock |
|
1375 TIsiSubBlock gpdsCompInfoSb( |
|
1376 messageData, |
|
1377 GPDS_COMP_INFO, |
|
1378 EIsiSubBlockTypeId8Len8 ); |
|
1379 |
|
1380 messageData.Append( aDataCompression ); |
|
1381 messageData.Append( aHeaderCompression ); |
|
1382 gpdsCompInfoSb.CompleteSubBlock(); |
|
1383 |
|
1384 // Add GPDS_SHARED_RADIO_ACTIVITY_REQ_INFO sub block |
|
1385 TIsiSubBlock radioActivitySubBlock( |
|
1386 messageData, |
|
1387 GPDS_SHARED_RADIO_ACTIVITY_REQ_INFO, |
|
1388 EIsiSubBlockTypeId8Len8 ); |
|
1389 |
|
1390 // contains no parameters |
|
1391 messageData.Append( KGpdsPadding ); |
|
1392 messageData.Append( KGpdsPadding ); |
|
1393 radioActivitySubBlock.CompleteSubBlock(); |
|
1394 |
|
1395 // Send Isi message via Phonet |
|
1396 return iPhoNetSender->Send( |
|
1397 PN_GPDS, GPDS_CONTEXT_CONFIGURE_REQ, |
|
1398 GPDS_CONTEXT_CONFIGURE_REQ, |
|
1399 messageData ); |
|
1400 } |
|
1401 |
|
1402 // ---------------------------------------------------------------------------- |
|
1403 // CMmPacketServiceMessHandler::MapNtwkRegStatus |
|
1404 // Maps network reg status to Packet Data reg status. |
|
1405 // ---------------------------------------------------------------------------- |
|
1406 // |
|
1407 RPacketService::TRegistrationStatus CMmPacketServiceMessHandler::MapNtwkRegStatus( |
|
1408 const TUint8 aRegistrationStatus, |
|
1409 const TUint8 aSuccessCode ) const |
|
1410 { |
|
1411 |
|
1412 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::MapNtwkRegStatus. aRegistrationStatus: %d", aRegistrationStatus); |
|
1413 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_MAPNTWKREGSTATUS, "CMmPacketServiceMessHandler::MapNtwkRegStatus;aRegistrationStatus=%hhu", aRegistrationStatus ); |
|
1414 |
|
1415 RPacketService::TRegistrationStatus registrationStatus( |
|
1416 RPacketService::EUnknown ); |
|
1417 |
|
1418 switch ( aRegistrationStatus ) |
|
1419 { |
|
1420 case NET_REG_STATUS_HOME: |
|
1421 { |
|
1422 // Registration status is ERegisteredOnHomeNetwork |
|
1423 registrationStatus = RPacketService::ERegisteredOnHomeNetwork; |
|
1424 break; |
|
1425 } |
|
1426 case NET_REG_STATUS_ROAM: |
|
1427 { |
|
1428 // Registration status is ERegisteredRoaming |
|
1429 registrationStatus = RPacketService::ERegisteredRoaming; |
|
1430 break; |
|
1431 } |
|
1432 case NET_REG_STATUS_NOSERV: |
|
1433 { |
|
1434 // if aSuccessCode is KNetCauseNetNotFound or |
|
1435 // KNetCauseNoSelectedNetwork |
|
1436 if ( NET_CAUSE_NET_NOT_FOUND == aSuccessCode || |
|
1437 NET_CAUSE_NO_SELECTED_NETWORK == aSuccessCode ) |
|
1438 { |
|
1439 // Registration status is ENotRegisteredAndNotAvailable |
|
1440 registrationStatus = |
|
1441 RPacketService::ENotRegisteredAndNotAvailable; |
|
1442 } |
|
1443 else |
|
1444 { |
|
1445 // Registration status is ENotRegisteredButAvailable |
|
1446 registrationStatus = |
|
1447 RPacketService::ENotRegisteredButAvailable; |
|
1448 } |
|
1449 break; |
|
1450 } |
|
1451 case NET_REG_STATUS_NOSERV_SEARCHING: |
|
1452 { |
|
1453 // Registration status is ENotRegisteredSearching |
|
1454 registrationStatus = RPacketService::ENotRegisteredSearching; |
|
1455 break; |
|
1456 } |
|
1457 case NET_REG_STATUS_NOSERV_NOTSEARCHING: |
|
1458 { |
|
1459 // Registration status is ENotRegisteredNotSearching |
|
1460 registrationStatus = RPacketService::ENotRegisteredNotSearching; |
|
1461 break; |
|
1462 } |
|
1463 case NET_REG_STATUS_NOSERV_NOSIM: |
|
1464 case NET_REG_STATUS_NOSERV_SIM_REJECTED_BY_NW: |
|
1465 { |
|
1466 // Registration status is ERegistrationDenied |
|
1467 registrationStatus = RPacketService::ERegistrationDenied; |
|
1468 break; |
|
1469 } |
|
1470 case NET_REG_STATUS_POWER_OFF: |
|
1471 case NET_REG_STATUS_NSPS: |
|
1472 { |
|
1473 // Registration status is ENotRegisteredAndNotAvailable |
|
1474 registrationStatus = RPacketService::ENotRegisteredAndNotAvailable; |
|
1475 break; |
|
1476 } |
|
1477 default: |
|
1478 { |
|
1479 |
|
1480 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::MapNtwkRegStatus: Default, DO NOTHING\n" ); |
|
1481 OstTrace0( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_MAPNTWKREGSTATUS, "CMmPacketServiceMessHandler::MapNtwkRegStatus, Default, DO NOTHING" ); |
|
1482 // Do nothing |
|
1483 break; |
|
1484 } |
|
1485 } |
|
1486 |
|
1487 TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::MapNtwkRegStatus.\n \t Registration Status Server:%d\n\t Registration Status Client:%d\n", aRegistrationStatus, registrationStatus ); |
|
1488 OstTraceExt2( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_MAPNTWKREGSTATUS, "CMmPacketServiceMessHandler::MapNtwkRegStatus;aRegistrationStatus=%hhu;registrationStatus=%d", aRegistrationStatus, registrationStatus ); |
|
1489 |
|
1490 return registrationStatus; |
|
1491 } |
|
1492 |
|
1493 // ---------------------------------------------------------------------------- |
|
1494 // CMmPacketServiceMessHandler::CompleteGsmRegistrationInfo |
|
1495 // Completes GSM Registration Info from GPDS Server. |
|
1496 // ---------------------------------------------------------------------------- |
|
1497 // |
|
1498 void CMmPacketServiceMessHandler::CompleteGsmRegistrationInfo( |
|
1499 const TBool aCsServices, |
|
1500 const TBool aGprsSupportInCell, |
|
1501 const TBool aEdgeGprsSupport ) |
|
1502 { |
|
1503 |
|
1504 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompleteGsmRegistrationInfo.\n" ); |
|
1505 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETEGSMREGISTRATIONINFO, "CMmPacketServiceMessHandler::CompleteGsmRegistrationInfo" ); |
|
1506 |
|
1507 CMmDataPackage data; |
|
1508 // save aCsServices internally |
|
1509 iLastCsServices = aCsServices; |
|
1510 // save aGprsSupportInCell internally |
|
1511 iLastGprsSupportInCell = aGprsSupportInCell; |
|
1512 |
|
1513 // check that value is changed |
|
1514 if ( iLastEdgeGprsSupport != aEdgeGprsSupport ) |
|
1515 { |
|
1516 iLastEdgeGprsSupport = aEdgeGprsSupport; |
|
1517 |
|
1518 // Pack data for completion |
|
1519 data.PackData( &iLastEdgeGprsSupport ); |
|
1520 |
|
1521 // EMmTsyNotifyEGprsInfoChangeIPC is internal IPC |
|
1522 iMessageRouter->Complete( |
|
1523 EMmTsyNotifyEGprsInfoChangeIPC, |
|
1524 &data, |
|
1525 KErrNone ); |
|
1526 } |
|
1527 //no else |
|
1528 |
|
1529 // call CompleteDynamicCapsChange() |
|
1530 CompleteDynamicCapsChange(); |
|
1531 } |
|
1532 |
|
1533 // ---------------------------------------------------------------------------- |
|
1534 // CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps |
|
1535 // Completes EPacketNotifyTransferCapsIPC. |
|
1536 // ---------------------------------------------------------------------------- |
|
1537 // |
|
1538 void CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps( |
|
1539 const TBool aEdgeGprsSupport ) |
|
1540 { |
|
1541 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps.\n" ); |
|
1542 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETEPACKETNOTIFYTRANSFERCAPS, "CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps" ); |
|
1543 |
|
1544 TDynamicTransferCapsFlags transferCaps ( 0 ); |
|
1545 |
|
1546 if ( aEdgeGprsSupport ) |
|
1547 { |
|
1548 transferCaps |= KCapsEGPRS; |
|
1549 |
|
1550 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps, Transfer Caps = %d.", transferCaps ); |
|
1551 OstTrace1( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_COMPLETEPACKETNOTIFYTRANSFERCAPS, "CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps;transferCaps=%d", transferCaps ); |
|
1552 } |
|
1553 |
|
1554 if ( iLastHsdpaAllocationStatus ) |
|
1555 { |
|
1556 transferCaps |= KCapsHSDPA; |
|
1557 |
|
1558 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps, Transfer Caps = %d.", transferCaps ); |
|
1559 OstTrace1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_COMPLETEPACKETNOTIFYTRANSFERCAPS, "CMmPacketServiceMessHandler::CompletePacketNotifyTransferCaps;transferCaps=%d", transferCaps ); |
|
1560 } |
|
1561 |
|
1562 CMmDataPackage dataPackage; |
|
1563 dataPackage.PackData( &transferCaps ); |
|
1564 |
|
1565 // Complete transfer caps |
|
1566 iMessageRouter->Complete ( |
|
1567 EPacketNotifyTransferCapsIPC, |
|
1568 &dataPackage, |
|
1569 KErrNone ); |
|
1570 } |
|
1571 |
|
1572 // ---------------------------------------------------------------------------- |
|
1573 // CMmPacketServiceMessHandler::CompleteDynamicCapsChange |
|
1574 // Completes dynamic capabilities change through Message manager |
|
1575 // Packs changed parameters |
|
1576 // ---------------------------------------------------------------------------- |
|
1577 // |
|
1578 void CMmPacketServiceMessHandler::CompleteDynamicCapsChange() |
|
1579 { |
|
1580 |
|
1581 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompleteDynamicCapsChange."); |
|
1582 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETEDYNAMICCAPSCHANGE, "CMmPacketServiceMessHandler::CompleteDynamicCapsChange" ); |
|
1583 |
|
1584 CMmDataPackage data; |
|
1585 data.PackData( &iLastGprsSupportInCell, &iLastCsServices ); |
|
1586 |
|
1587 iMessageRouter->Complete ( |
|
1588 EPacketNotifyDynamicCapsChange, |
|
1589 &data, |
|
1590 KErrNone ); |
|
1591 } |
|
1592 |
|
1593 // ---------------------------------------------------------------------------- |
|
1594 // CMmPacketServiceMessHandler::SetAttachMode |
|
1595 // Sets attach mode to the GPDS server. |
|
1596 // ---------------------------------------------------------------------------- |
|
1597 // |
|
1598 TInt CMmPacketServiceMessHandler::SetAttachMode( |
|
1599 RPacketService::TAttachMode* const aMode ) |
|
1600 { |
|
1601 |
|
1602 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::SetAttachMode.\n\t Attach Mode:%d\n", *aMode ); |
|
1603 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_SETATTACHMODE, "CMmPacketServiceMessHandler::SetAttachMode;aMode=%hhu", *aMode ); |
|
1604 |
|
1605 TInt ret( KErrNone ); |
|
1606 TUint8 attachMode( GPDS_ATTACH_MODE_DEFAULT ); |
|
1607 |
|
1608 if ( RPacketService::EAttachWhenPossible == *aMode ) |
|
1609 { |
|
1610 attachMode = GPDS_ATTACH_MODE_AUTOMATIC; |
|
1611 } |
|
1612 else if ( RPacketService::EAttachWhenNeeded == *aMode ) |
|
1613 { |
|
1614 attachMode = GPDS_ATTACH_MODE_MANUAL; |
|
1615 } |
|
1616 else |
|
1617 { |
|
1618 ret = KErrArgument; |
|
1619 } |
|
1620 |
|
1621 if ( KErrNone == ret ) |
|
1622 { |
|
1623 // GPDS_CONFIGURE_REQ is for identifying calling method |
|
1624 ret = GpdsConfigureReq( |
|
1625 GPDS_CONFIGURE_REQ, |
|
1626 attachMode, |
|
1627 GPDS_MT_ACT_MODE_DEFAULT, |
|
1628 GPDS_CLASSC_MODE_DEFAULT, |
|
1629 iAlwaysOnMode ); |
|
1630 } |
|
1631 //no else |
|
1632 |
|
1633 return ret; |
|
1634 } |
|
1635 |
|
1636 // ---------------------------------------------------------------------------- |
|
1637 // CMmPacketServiceMessHandler::PacketContextList |
|
1638 // Returns poineter to CMmPacketMesshandlerContextList |
|
1639 // ---------------------------------------------------------------------------- |
|
1640 // |
|
1641 CMmPacketContextMesshandlerList* CMmPacketServiceMessHandler::PacketContextList() |
|
1642 { |
|
1643 |
|
1644 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::PacketContextList."); |
|
1645 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_PACKETCONTEXTLIST, "CMmPacketServiceMessHandler::PacketContextList" ); |
|
1646 |
|
1647 return iPacketMesshandlerContextList; |
|
1648 } |
|
1649 |
|
1650 // ---------------------------------------------------------------------------- |
|
1651 // CMmPacketServiceMessHandler::GetMessageRouter |
|
1652 // Returns pointer to MessageRouter |
|
1653 // ---------------------------------------------------------------------------- |
|
1654 // |
|
1655 CMmMessageRouter* CMmPacketServiceMessHandler::GetMessageRouter() |
|
1656 { |
|
1657 |
|
1658 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GetMessageRouter"); |
|
1659 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_GETMESSAGEROUTER, "CMmPacketServiceMessHandler::GetMessageRouter" ); |
|
1660 |
|
1661 return iMessageRouter; |
|
1662 } |
|
1663 |
|
1664 |
|
1665 // ---------------------------------------------------------------------------- |
|
1666 // CMmPacketServiceMessHandler::SetPreferredBearer |
|
1667 // Sets preferrer bearer to the GPDS server. |
|
1668 // ---------------------------------------------------------------------------- |
|
1669 // |
|
1670 TInt CMmPacketServiceMessHandler::SetPreferredBearer( |
|
1671 const CMmDataPackage& aDataPackage ) |
|
1672 { |
|
1673 |
|
1674 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SetPreferredBearer"); |
|
1675 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_SETPREFERREDBEARER, "CMmPacketServiceMessHandler::SetPreferredBearer" ); |
|
1676 |
|
1677 RPacketService::TPreferredBearer* abearer = NULL; |
|
1678 TInt ret( KErrNone ); |
|
1679 |
|
1680 aDataPackage.UnPackData( &abearer ); |
|
1681 |
|
1682 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::SetPreferredBearer.\n\t Preferred Bearer:%d\n", &abearer ); |
|
1683 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_SETPREFERREDBEARER, "CMmPacketServiceMessHandler::SetPreferredBearer;abearer=%hhu", *abearer ); |
|
1684 |
|
1685 TUint8 bearer( GPDS_CLASSC_MODE_DEFAULT ); |
|
1686 |
|
1687 if ( RPacketService::EBearerCircuitSwitched == *abearer ) |
|
1688 { |
|
1689 bearer = GPDS_CLASSC_MODE_GSM; |
|
1690 } |
|
1691 else if ( RPacketService::EBearerPacketSwitched == *abearer ) |
|
1692 { |
|
1693 bearer = GPDS_CLASSC_MODE_GPRS; |
|
1694 } |
|
1695 else |
|
1696 { |
|
1697 ret = KErrArgument; |
|
1698 } |
|
1699 |
|
1700 if ( KErrNone == ret ) |
|
1701 { |
|
1702 // 0xDC - KDummyTrIdDC is dummy for indentifying calling method |
|
1703 ret = GpdsConfigureReq( |
|
1704 KDummyTrIdDC, |
|
1705 GPDS_ATTACH_MODE_DEFAULT, |
|
1706 GPDS_MT_ACT_MODE_ACCEPT, |
|
1707 bearer, |
|
1708 iAlwaysOnMode ); |
|
1709 } |
|
1710 //no else |
|
1711 |
|
1712 return ret; |
|
1713 } |
|
1714 |
|
1715 // ---------------------------------------------------------------------------- |
|
1716 // CMmPacketServiceMessHandler::SetDefaultContextParams |
|
1717 // Set default context parameters |
|
1718 // ---------------------------------------------------------------------------- |
|
1719 // |
|
1720 TInt CMmPacketServiceMessHandler::SetDefaultContextParams( |
|
1721 const CMmDataPackage& aPackage ) |
|
1722 { |
|
1723 |
|
1724 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SetDefaultContextParams"); |
|
1725 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_SETDEFAULTCONTEXTPARAMS, "CMmPacketServiceMessHandler::SetDefaultContextParams" ); |
|
1726 |
|
1727 TInt ret( KErrNotSupported ); |
|
1728 TUint8 dataCompression( GPDS_PDP_HCOMP_DEFAULT ); |
|
1729 TUint8 headerCompression( GPDS_PDP_HCOMP_DEFAULT ); |
|
1730 // temporary access point name |
|
1731 RPacketContext::TGSNAddress tempAccessPointName; |
|
1732 // temporary Pdp Type |
|
1733 RPacketContext::TProtocolType tempPdpType( RPacketContext::EPdpTypeCDPD ); |
|
1734 |
|
1735 TPacketDataConfigBase* aconfig = NULL; |
|
1736 aPackage.UnPackData ( &aconfig ); |
|
1737 |
|
1738 // Check that the mode given in aconfig is GPRS |
|
1739 if ( TPacketDataConfigBase::KConfigGPRS == aconfig->ExtensionId() ) |
|
1740 { |
|
1741 |
|
1742 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SetDefaultContextParams. ExtensionId: KConfigGPRS"); |
|
1743 OstTrace0( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_SETDEFAULTCONTEXTPARAMS, "CMmPacketServiceMessHandler::SetDefaultContextParams, ExtensionId: KConfigGPRS" ); |
|
1744 |
|
1745 RPacketContext::TContextConfigGPRS& configGPRS = |
|
1746 *reinterpret_cast<RPacketContext::TContextConfigGPRS*>( aconfig ); |
|
1747 |
|
1748 // Set data compression |
|
1749 dataCompression = GPDS_PDP_HCOMP_OFF; |
|
1750 |
|
1751 if ( configGPRS.iPdpCompression & |
|
1752 RPacketContext::KPdpDataCompression ) |
|
1753 { |
|
1754 dataCompression = GPDS_PDP_HCOMP_ON; |
|
1755 } |
|
1756 //no else |
|
1757 |
|
1758 // Set header compression |
|
1759 headerCompression = GPDS_PDP_HCOMP_OFF; |
|
1760 |
|
1761 if ( configGPRS.iPdpCompression & |
|
1762 RPacketContext::KPdpHeaderCompression ) |
|
1763 { |
|
1764 headerCompression = GPDS_PDP_HCOMP_ON; |
|
1765 } |
|
1766 //no else |
|
1767 |
|
1768 tempAccessPointName = configGPRS.iAccessPointName; |
|
1769 tempPdpType = configGPRS.iPdpType; |
|
1770 } |
|
1771 |
|
1772 // Check that the mode given in aconfig is R99_R4 |
|
1773 else if ( TPacketDataConfigBase::KConfigRel99Rel4 == |
|
1774 aconfig->ExtensionId() ) |
|
1775 { |
|
1776 |
|
1777 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SetDefaultContextParams. ExtensionId: KConfigRel99Rel4"); |
|
1778 OstTrace0( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_SETDEFAULTCONTEXTPARAMS, "CMmPacketServiceMessHandler::SetDefaultContextParams, ExtensionId: KConfigRel99Rel4" ); |
|
1779 |
|
1780 RPacketContext::TContextConfigR99_R4& configR99_R4 = |
|
1781 *reinterpret_cast<RPacketContext::TContextConfigR99_R4*>( |
|
1782 aconfig ); |
|
1783 |
|
1784 tempAccessPointName = configR99_R4.iAccessPointName; |
|
1785 tempPdpType = configR99_R4.iPdpType; |
|
1786 } |
|
1787 //no else |
|
1788 |
|
1789 TUint8 pdpType( GPDS_PDP_TYPE_DEFAULT ); |
|
1790 |
|
1791 // This part is for pdp type mapping |
|
1792 if ( RPacketContext::EPdpTypeIPv4 == tempPdpType ) |
|
1793 { |
|
1794 pdpType = GPDS_PDP_TYPE_IPV4; |
|
1795 } |
|
1796 else if ( RPacketContext::EPdpTypeIPv6 == tempPdpType ) |
|
1797 { |
|
1798 pdpType = GPDS_PDP_TYPE_IPV6; |
|
1799 } |
|
1800 else if ( RPacketContext::EPdpTypePPP == tempPdpType ) |
|
1801 { |
|
1802 pdpType = GPDS_PDP_TYPE_PPP; |
|
1803 } |
|
1804 else |
|
1805 { |
|
1806 pdpType = GPDS_PDP_TYPE_DEFAULT; |
|
1807 } |
|
1808 |
|
1809 if ( GPDS_PDP_TYPE_DEFAULT != pdpType ) |
|
1810 { |
|
1811 // Call GpdsContextConfigureReq |
|
1812 ret = GpdsContextConfigureReq( |
|
1813 dataCompression, |
|
1814 headerCompression, |
|
1815 tempAccessPointName, |
|
1816 pdpType ); |
|
1817 } |
|
1818 //no else |
|
1819 |
|
1820 return ret; |
|
1821 } |
|
1822 |
|
1823 // ---------------------------------------------------------------------------- |
|
1824 // CMmPacketServiceMessHandler::CompleteTransferStatusIndication |
|
1825 // Completes Transfer Status Indication. |
|
1826 // ---------------------------------------------------------------------------- |
|
1827 // |
|
1828 void CMmPacketServiceMessHandler::CompleteTransferStatusIndication( |
|
1829 const TUint8 aTransferCause ) |
|
1830 { |
|
1831 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::CompleteTransferStatusIndication.\n \t Transfer Cause:%d\n", aTransferCause ); |
|
1832 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETETRANSFERSTATUSINDICATION, "CMmPacketServiceMessHandler::CompleteTransferStatusIndication;aTransferCause=%hhu", aTransferCause ); |
|
1833 |
|
1834 RPacketService::TStatus packetStatus( RPacketService::EStatusAttached ); |
|
1835 RMmCustomAPI::TRauEventStatus rauindication( RMmCustomAPI::ERauEventActive ); |
|
1836 |
|
1837 TInt error( KErrNone ); |
|
1838 TBool resumed( EFalse ); |
|
1839 TBool completeToTsy( ETrue ); |
|
1840 // Pack and complete |
|
1841 CMmDataPackage data; |
|
1842 |
|
1843 switch ( aTransferCause ) |
|
1844 { |
|
1845 case GPDS_TRANSFER_CAUSE_RESUMED: |
|
1846 { |
|
1847 resumed = ETrue; |
|
1848 rauindication = RMmCustomAPI::ERauEventResumed; |
|
1849 data.PackData( &rauindication ); |
|
1850 iMessageRouter->Complete( ECustomNotifyRauEventIPC, &data, error ); |
|
1851 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::CompleteTransferStatusIndicationResumed.\n \t Rau indication:%d\n", rauindication ); |
|
1852 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_COMPLETETRANSFERSTATUSINDICATION, "CMmPacketServiceMessHandler::CompleteTransferStatusIndication;rauindication=%hhu", rauindication ); |
|
1853 break; |
|
1854 } |
|
1855 case GPDS_TRANSFER_CAUSE_ATTACHED: |
|
1856 { |
|
1857 // packetStatus is 'RPacketService::EStatusAttached' by default, do nothing |
|
1858 break; |
|
1859 } |
|
1860 case GPDS_TRANSFER_CAUSE_DETACHED: |
|
1861 { |
|
1862 packetStatus = RPacketService::EStatusUnattached; |
|
1863 break; |
|
1864 } |
|
1865 case GPDS_TRANSFER_CAUSE_SUSPENDED_NO_COVERAGE: |
|
1866 case GPDS_TRANSFER_CAUSE_SUSPENDED_CALL_SMS: |
|
1867 case GPDS_TRANSFER_CAUSE_SUSPENDED_CALL: |
|
1868 { |
|
1869 packetStatus = RPacketService::EStatusSuspended; |
|
1870 break; |
|
1871 } |
|
1872 case GPDS_TRANSFER_CAUSE_SUSPENDED_RAU : |
|
1873 { |
|
1874 TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::CompleteTransferStatusIndicationActivated.\n \t Rau indication:%d\n", rauindication ); |
|
1875 OstTraceExt1( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_COMPLETETRANSFERSTATUSINDICATION, "CMmPacketServiceMessHandler::CompleteTransferStatusIndication;rauindication=%hhu", rauindication ); |
|
1876 // rauindication is 'RMmCustomAPI::ERauEventActive' by default, no need to set here |
|
1877 data.PackData( &rauindication ); |
|
1878 iMessageRouter->Complete( ECustomNotifyRauEventIPC, &data, error ); |
|
1879 completeToTsy = EFalse; |
|
1880 break; |
|
1881 } |
|
1882 case GPDS_TRANSFER_CAUSE_SUSPENDED_LU : |
|
1883 { |
|
1884 completeToTsy = EFalse; |
|
1885 break; |
|
1886 } |
|
1887 #if ( NCP_COMMON_CELLMO_BRANCH_SUPPORT == NCP_COMMON_CELLMO_BRANCH_0711 ) |
|
1888 case GPDS_TRANSFER_CAUSE_DSAC_RESTRICTION: |
|
1889 { |
|
1890 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompleteTransferStatusIndication. DSAC: connection failed because of barred PS \n"); |
|
1891 OstTrace0( TRACE_NORMAL, DUP4_CMMPACKETSERVICEMESSHANDLER_COMPLETETRANSFERSTATUSINDICATION, "CMmPacketServiceMessHandler::CompleteTransferStatusIndication, DSAC: connection failed because of barred PS \n" ); |
|
1892 // Core error and extended error are completed to CTSY |
|
1893 error = ( KErrGeneral & 0x0000FFFF ) | |
|
1894 ( KErrGsmPSConnectionBarred << 16 ); |
|
1895 break; |
|
1896 } |
|
1897 #endif // NCP_COMMON_CELLMO_BRANCH_SUPPORT == NCP_COMMON_CELLMO_BRANCH_0711 |
|
1898 default: |
|
1899 { |
|
1900 |
|
1901 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompleteTransferStatusIndication.Default case: DO NOTHING\n"); |
|
1902 OstTrace0( TRACE_NORMAL, DUP3_CMMPACKETSERVICEMESSHANDLER_COMPLETETRANSFERSTATUSINDICATION, "CMmPacketServiceMessHandler::CompleteTransferStatusIndication, Default case: DO NOTHING" ); |
|
1903 break; |
|
1904 } |
|
1905 } |
|
1906 |
|
1907 if ( completeToTsy ) |
|
1908 { |
|
1909 //Pack and complete |
|
1910 CMmDataPackage data; |
|
1911 data.PackData( &packetStatus, &resumed ); |
|
1912 iMessageRouter->Complete( |
|
1913 EPacketNotifyStatusChange, &data, error ); |
|
1914 |
|
1915 CompleteDynamicCapsChange(); |
|
1916 } |
|
1917 //no else |
|
1918 } |
|
1919 |
|
1920 // ---------------------------------------------------------------------------- |
|
1921 // CMmPacketServiceMessHandler::CompleteNotifyMSClassChange |
|
1922 // Completes MS Class change notification to the Service Tsy. |
|
1923 // ---------------------------------------------------------------------------- |
|
1924 // |
|
1925 void CMmPacketServiceMessHandler::CompleteNotifyMSClassChange( |
|
1926 const TUint8 aGprsNetworkMode ) |
|
1927 { |
|
1928 |
|
1929 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::CompleteNotifyMSClassChange"); |
|
1930 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETENOTIFYMSCLASSCHANGE, "CMmPacketServiceMessHandler::CompleteNotifyMSClassChange" ); |
|
1931 |
|
1932 CMmDataPackage data; |
|
1933 RPacketService::TMSClass msClass( RPacketService::EMSClassUnknown ); |
|
1934 |
|
1935 // If Gprs supported in current cell |
|
1936 if ( iLastGprsSupportInCell ) |
|
1937 { |
|
1938 if ( RMobilePhone::ENetworkModeWcdma == iCurrentMode || |
|
1939 iLastDtmSupportInCell ) |
|
1940 { |
|
1941 // MS Class is Class A |
|
1942 msClass = RPacketService::EMSClassDualMode; |
|
1943 } |
|
1944 else if ( NET_GPRS_MODE_II == aGprsNetworkMode || |
|
1945 NET_GPRS_MODE_I == aGprsNetworkMode ) |
|
1946 { |
|
1947 // MS Class is Class B |
|
1948 msClass = RPacketService::EMSClassSuspensionRequired; |
|
1949 } |
|
1950 else if ( NET_GPRS_MODE_III == aGprsNetworkMode ) |
|
1951 { |
|
1952 if ( iLastCsServices ) |
|
1953 { |
|
1954 // MS Class is Class C where cs and gprs both are supported |
|
1955 msClass = RPacketService::EMSClassAlternateMode; |
|
1956 } |
|
1957 else |
|
1958 { |
|
1959 // MS Class is Class C where only gprs is supported |
|
1960 msClass = RPacketService::EMSClassPacketSwitchedOnly; |
|
1961 } |
|
1962 } |
|
1963 //no else |
|
1964 } |
|
1965 else if ( iLastCsServices ) |
|
1966 { |
|
1967 // MS Class is Class C where only cs is supported |
|
1968 msClass = RPacketService::EMSClassCircuitSwitchedOnly; |
|
1969 } |
|
1970 //no else |
|
1971 |
|
1972 // Pack and complete |
|
1973 data.PackData( &msClass ); |
|
1974 iMessageRouter->Complete( |
|
1975 EPacketNotifyMSClassChange, |
|
1976 &data, |
|
1977 KErrNone ); |
|
1978 } |
|
1979 |
|
1980 // ---------------------------------------------------------------------------- |
|
1981 // CMmPacketServiceMessHandler::CompleteGpdsStatusRequest |
|
1982 // Completes Gpds Status Request. |
|
1983 // ---------------------------------------------------------------------------- |
|
1984 // |
|
1985 void CMmPacketServiceMessHandler::CompleteGpdsStatusRequest( |
|
1986 const TUint8 aAttachStatus, |
|
1987 const TUint8 aTransferStatus ) |
|
1988 { |
|
1989 |
|
1990 TFLOGSTRING3("TSY: CMmPacketService::CompleteGpdsStatusRequest.\n\t Attach Status:%d\n\t Transfer Status:%d\n", aAttachStatus, aTransferStatus ); |
|
1991 OstTraceExt1( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_COMPLETEGPDSSTATUSREQUEST, "CMmPacketServiceMessHandler::CompleteGpdsStatusRequest;aAttachStatus=%hhu", aAttachStatus ); |
|
1992 |
|
1993 // Initiate EStatusAttached to packet status |
|
1994 RPacketService::TStatus packetStatus( RPacketService::EStatusAttached ); |
|
1995 |
|
1996 if ( GPDS_DETACHED == aAttachStatus ) |
|
1997 { |
|
1998 // If attach status is detached, packet status is unattached |
|
1999 packetStatus = RPacketService::EStatusUnattached; |
|
2000 } |
|
2001 else if ( GPDS_TRANSFER_NOT_AVAIL == aTransferStatus ) |
|
2002 { |
|
2003 // If attach status is attached and transfer status is not available, |
|
2004 // packet status is suspended |
|
2005 packetStatus = RPacketService::EStatusSuspended; |
|
2006 } |
|
2007 |
|
2008 TBool resumed( EFalse ); |
|
2009 CMmDataPackage data; |
|
2010 data.PackData( &packetStatus, &resumed ); |
|
2011 |
|
2012 // Complete |
|
2013 iMessageRouter->Complete( |
|
2014 EPacketNotifyStatusChange, |
|
2015 &data, |
|
2016 KErrNone ); |
|
2017 } |
|
2018 |
|
2019 // ---------------------------------------------------------------------------- |
|
2020 // CMmPacketServiceMessHandler:NetRatReq |
|
2021 // Current Network Radio Access Technology Request |
|
2022 // ---------------------------------------------------------------------------- |
|
2023 // |
|
2024 TInt CMmPacketServiceMessHandler::NetRatReq() |
|
2025 { |
|
2026 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetRatReq"); |
|
2027 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NETRATREQ, "CMmPacketServiceMessHandler::NetRatReq" ); |
|
2028 |
|
2029 // Set the message data that consists of one parameters |
|
2030 TBuf8<KBuffSizeOneByte> messageData; |
|
2031 // Ask information of current network radio access technology |
|
2032 messageData.Append( NET_CURRENT_RAT ); |
|
2033 |
|
2034 // Send Isi message via Phonet |
|
2035 return( iPhoNetSender->Send( |
|
2036 PN_MODEM_NETWORK, |
|
2037 KDummyTrIdDC, |
|
2038 NET_RAT_REQ, |
|
2039 messageData ) ); |
|
2040 } |
|
2041 |
|
2042 // ---------------------------------------------------------------------------- |
|
2043 // CMmPacketServiceMessHandler::NetRatIndOrResp |
|
2044 // Breaks NET_RAT_IND and NET_RAT_RESP ISI-messages. |
|
2045 // ---------------------------------------------------------------------------- |
|
2046 // |
|
2047 void CMmPacketServiceMessHandler::NetRatIndOrResp( |
|
2048 const TIsiReceiveC &aIsiMessage ) |
|
2049 { |
|
2050 |
|
2051 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetRatIndOrResp"); |
|
2052 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NETRATINDORRESP, "CMmPacketServiceMessHandler::NetRatIndOrResp" ); |
|
2053 |
|
2054 TBool readSubBlock( ETrue ); |
|
2055 TBool isNetRatResp( NET_RAT_RESP == aIsiMessage. |
|
2056 Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) ); |
|
2057 |
|
2058 // If received message is response then transaction id must be dummy 0xDC |
|
2059 // and success code must ok. |
|
2060 if ( isNetRatResp ) |
|
2061 { |
|
2062 // 0xDC - KDummyTrIdDC is dummy transaction id |
|
2063 if ( NET_CAUSE_INVALID_PARAMETER == aIsiMessage.Get8bit( ISI_HEADER_SIZE + |
|
2064 NET_RAT_RESP_OFFSET_SUCCESSCODE ) || KDummyTrIdDC != aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) ) |
|
2065 { |
|
2066 readSubBlock = EFalse; |
|
2067 } |
|
2068 //no else |
|
2069 } |
|
2070 //no else |
|
2071 |
|
2072 if ( readSubBlock ) |
|
2073 { |
|
2074 TUint sbStartOffSet( 0 ); |
|
2075 TInt ret( 0 ); |
|
2076 |
|
2077 // Get network registration info common sub block |
|
2078 if ( isNetRatResp ) |
|
2079 { |
|
2080 ret = aIsiMessage.FindSubBlockOffsetById( ISI_HEADER_SIZE + |
|
2081 SIZE_NET_RAT_RESP ,NET_RAT_INFO, EIsiSubBlockTypeId8Len8, sbStartOffSet ); |
|
2082 } |
|
2083 else |
|
2084 { |
|
2085 ret = aIsiMessage.FindSubBlockOffsetById( ISI_HEADER_SIZE + |
|
2086 SIZE_NET_RAT_IND ,NET_RAT_INFO, EIsiSubBlockTypeId8Len8, sbStartOffSet ); |
|
2087 } |
|
2088 |
|
2089 if ( KErrNone == ret ) |
|
2090 { |
|
2091 // Get Rat Name |
|
2092 TUint8 ratName( aIsiMessage.Get8bit( sbStartOffSet + |
|
2093 NET_RAT_INFO_OFFSET_RATNAME ) ); |
|
2094 |
|
2095 RMobilePhone::TMobilePhoneNetworkMode ntwkMode( |
|
2096 RMobilePhone::ENetworkModeUnknown ); |
|
2097 |
|
2098 // If Gsm Rat is supported |
|
2099 if ( NET_GSM_RAT == ratName ) |
|
2100 { |
|
2101 // GSM currently not supported. |
|
2102 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetRatIndOrResp. RMobilePhone::ENetworkModeGsm"); |
|
2103 |
|
2104 ntwkMode = RMobilePhone::ENetworkModeGsm; |
|
2105 OstTrace0( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_NETRATINDORRESP, "CMmPacketServiceMessHandler::NetRatIndOrResp, RMobilePhone::ENetworkModeGsm" ); |
|
2106 } |
|
2107 // Else if Wcdma Rat is supported |
|
2108 else if ( NET_UMTS_RAT == ratName ) |
|
2109 { |
|
2110 // WCDMA currently not supported. |
|
2111 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NetRatIndOrResp. RMobilePhone::ENetworkModeWcdma"); |
|
2112 OstTrace0( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_NETRATINDORRESP, "CMmPacketServiceMessHandler::NetRatIndOrResp, RMobilePhone::ENetworkModeWcdma" ); |
|
2113 ntwkMode = RMobilePhone::ENetworkModeWcdma; |
|
2114 } |
|
2115 |
|
2116 // Store networkmode internally |
|
2117 iCurrentMode = ntwkMode; |
|
2118 |
|
2119 CMmDataPackage data; |
|
2120 data.PackData( &ntwkMode ); |
|
2121 |
|
2122 // Complete EPacketNotifyReleaseModeChange IPC is used for this request |
|
2123 iMessageRouter->Complete( |
|
2124 EPacketNotifyReleaseModeChange, |
|
2125 &data, |
|
2126 KErrNone ); |
|
2127 } |
|
2128 //no else |
|
2129 } |
|
2130 //no else |
|
2131 } |
|
2132 |
|
2133 // ---------------------------------------------------------------------------- |
|
2134 // CMmPacketServiceMessHandler::HandleError |
|
2135 // Handles CMmPacketServiceMessHandler's errors |
|
2136 // that comes via PhoNetReceiver RunError method. |
|
2137 // ---------------------------------------------------------------------------- |
|
2138 // |
|
2139 void CMmPacketServiceMessHandler::HandleError( |
|
2140 const TIsiReceiveC& /*aIsiMessage*/, |
|
2141 TInt /*aError*/ ) |
|
2142 { |
|
2143 |
|
2144 TFLOGSTRING("TSY: CMmPacketServiceMessHandler::HandleError DO NOTHING"); |
|
2145 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_HANDLEERROR, "CMmPacketServiceMessHandler::HandleError DO NOTHING" ); |
|
2146 //none |
|
2147 } |
|
2148 |
|
2149 // ----------------------------------------------------------------------------- |
|
2150 // CMmPacketServiceMessHandler::NetRadioInfoInd |
|
2151 // Breaks a NET_RADIO_INFO_IND ISI message. Check the HSDPA allocated status |
|
2152 // and completes with EPacketNotifyTransferCapsIPC. |
|
2153 // ----------------------------------------------------------------------------- |
|
2154 // |
|
2155 void CMmPacketServiceMessHandler::NetRadioInfoInd( |
|
2156 const TIsiReceiveC& aIsiMessage ) // received ISI message |
|
2157 { |
|
2158 |
|
2159 TFLOGSTRING( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd" ); |
|
2160 OstTrace0( TRACE_NORMAL, CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd" ); |
|
2161 |
|
2162 TDynamicTransferCapsFlags transferCaps ( 0 ); |
|
2163 TBool hsdpaAllocated ( EFalse ); |
|
2164 |
|
2165 // Find NET_UTRAN_RADIO_INFO sub block |
|
2166 TUint sbStartOffSet = 0; |
|
2167 TInt retValue = aIsiMessage.FindSubBlockOffsetById( ISI_HEADER_SIZE + |
|
2168 SIZE_NET_RADIO_INFO_IND, NET_UTRAN_RADIO_INFO, |
|
2169 EIsiSubBlockTypeId8Len8, sbStartOffSet ); |
|
2170 |
|
2171 if ( KErrNone == retValue ) |
|
2172 { |
|
2173 // Get HSDPA allocation status |
|
2174 hsdpaAllocated = aIsiMessage.Get8bit( sbStartOffSet + |
|
2175 NET_UTRAN_RADIO_INFO_OFFSET_HSDPAALLOCATED ); |
|
2176 |
|
2177 // Save HSDPA allocation status |
|
2178 iLastHsdpaAllocationStatus = hsdpaAllocated; |
|
2179 |
|
2180 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd, HSDPA Allocated = %d.", hsdpaAllocated ); |
|
2181 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd;hsdpaAllocated=%hhu", hsdpaAllocated ); |
|
2182 } |
|
2183 |
|
2184 // Dynamic transfer caps |
|
2185 if ( hsdpaAllocated ) |
|
2186 { |
|
2187 transferCaps |= KCapsHSDPA; |
|
2188 |
|
2189 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd, Transfer Caps = %d.", transferCaps ); |
|
2190 OstTrace1( TRACE_NORMAL, DUP3_CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd;transferCaps=%d", transferCaps ); |
|
2191 } |
|
2192 |
|
2193 // This is done for SUB 403-7200: NokiaTSY: HSUPA Cell Indicator for S60 (S60 3.2.2 / S_CPR8.1). |
|
2194 // This can be removed when actual implementation for HSUPA Cell Indicator is done. |
|
2195 // CASW_HSXPA_INDICATOR_SUPPORTED flag. |
|
2196 #if defined ( CASW_HSXPA_INDICATOR_SUPPORTED ) || defined ( INTERNAL_TESTING_CASW_HSXPA_INDICATOR_SUPPORT ) |
|
2197 |
|
2198 TBool hsupaAllocated ( EFalse ); |
|
2199 |
|
2200 if ( KErrNone == retValue ) |
|
2201 { |
|
2202 // Get HSUPA allocation status |
|
2203 hsupaAllocated = aIsiMessage.Get8bit( sbStartOffSet + |
|
2204 NET_UTRAN_RADIO_INFO_OFFSET_HSUPAALLOCATED ); |
|
2205 |
|
2206 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd, HSUPA Allocated = %d.", hsupaAllocated ); |
|
2207 OstTraceExt1( TRACE_NORMAL, DUP2_CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd;hsupaAllocated=%hhu", hsupaAllocated ); |
|
2208 } |
|
2209 |
|
2210 if ( hsdpaAllocated || hsupaAllocated ) |
|
2211 { |
|
2212 transferCaps |= KCapsHSDPA; |
|
2213 |
|
2214 // Save HSDPA allocation status |
|
2215 iLastHsdpaAllocationStatus = ETrue; |
|
2216 |
|
2217 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd, Transfer Caps (HSDPA or HSUPA) = %d.", transferCaps ); |
|
2218 OstTrace1( TRACE_NORMAL, DUP4_CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd;transferCaps=%d", transferCaps ); |
|
2219 |
|
2220 } |
|
2221 #endif // defined ( CASW_HSXPA_INDICATOR_SUPPORTED ) || defined ( INTERNAL_TESTING_CASW_HSXPA_INDICATOR_SUPPORT ) |
|
2222 |
|
2223 if ( iLastEdgeGprsSupport ) |
|
2224 { |
|
2225 transferCaps |= KCapsEGPRS; |
|
2226 |
|
2227 TFLOGSTRING2( "TSY: CMmPacketServiceMessHandler::NetRadioInfoInd, Transfer Caps = %d.", transferCaps ); |
|
2228 OstTrace1( TRACE_NORMAL, DUP5_CMMPACKETSERVICEMESSHANDLER_NETRADIOINFOIND, "CMmPacketServiceMessHandler::NetRadioInfoInd;transferCaps=%d", transferCaps ); |
|
2229 } |
|
2230 |
|
2231 // Pack the data |
|
2232 CMmDataPackage dataPackage; |
|
2233 dataPackage.PackData( &transferCaps ); |
|
2234 // Complete transfer caps |
|
2235 iMessageRouter->Complete ( |
|
2236 EPacketNotifyTransferCapsIPC, |
|
2237 &dataPackage, |
|
2238 KErrNone ); |
|
2239 } |
|
2240 |
|
2241 // End of File |
|
2242 |