|
1 /* |
|
2 * Copyright (c) 2002-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: This module contains the implementation of CNWMessageHandler |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include "NWHandlingEngine.h" |
|
22 #include "CNWMessageHandler.h" |
|
23 #include "CNWNetworkCurrentNetworkMonitor.h" |
|
24 #include "CNWNetworkRegistrationStatusMonitor.h" |
|
25 #include "CNWProgrammableOperatorNameCommand.h" |
|
26 #include "CNWServiceProviderNameCommand.h" |
|
27 #include "CNWNetworkModeMonitor.h" |
|
28 #include "CNWNetworkProviderNameCommand.h" |
|
29 #include "CNWSubscriberIdCommand.h" |
|
30 #include "NWLogger.h" |
|
31 #ifdef RD_PHONE_NG |
|
32 #include "cnwnetworkselectionsettingmonitor.h" |
|
33 #endif // RD_PHONE_NG |
|
34 // CONSTANTS |
|
35 const TInt KNWNetworkMonitorCurrent = 0; |
|
36 const TInt KNWNetworkMonitorMode = 1; |
|
37 const TInt KNWNetworkMonitorRegistration = 2; |
|
38 #ifdef RD_PHONE_NG |
|
39 const TInt KNWNetworkMonitorSettingSelection = 3; |
|
40 #endif // RD_PHONE_NG |
|
41 |
|
42 |
|
43 // ============================ MEMBER FUNCTIONS ============================== |
|
44 |
|
45 // ---------------------------------------------------------------------------- |
|
46 // CNWMessageHandler::CNWMessageHandler |
|
47 // C++ default constructor can NOT contain any code, that |
|
48 // might leave. |
|
49 // ---------------------------------------------------------------------------- |
|
50 // |
|
51 EXPORT_C CNWMessageHandler::CNWMessageHandler( |
|
52 CNWSession& aNetworkData, |
|
53 MNWMessageObserver& aMessageObserver, |
|
54 TNWInfo& aNWInfo ) |
|
55 : iNetworkData( aNetworkData ), |
|
56 iMessageObserver( aMessageObserver ), |
|
57 iNetworkInfo( aNWInfo ) |
|
58 { |
|
59 NWLOGSTRING( KNWOBJECT, |
|
60 "NW: CNWMessageHandler::CNWMessageHandler() Begin" ); |
|
61 |
|
62 // initialise current network info |
|
63 iNetworkInfo.iRegistrationStatus = ENWRegistrationUnknown; |
|
64 iNetworkInfo.iNetworkMode = ENWModeUnknown; |
|
65 iNetworkInfo.iStatus = ENWStatusUnknown; |
|
66 iNetworkInfo.iCountryCode = KNullDesC; |
|
67 iNetworkInfo.iNetworkId = KNullDesC; |
|
68 iNetworkInfo.iDisplayTag = KNullDesC; |
|
69 iNetworkInfo.iShortName = KNullDesC; |
|
70 iNetworkInfo.iLongName = KNullDesC; |
|
71 iNetworkInfo.iViagIndicatorType = ENWViagIndicatorTypeNone; |
|
72 iNetworkInfo.iViagTextTag = KNullDesC; |
|
73 iNetworkInfo.iMCNIndicatorType = ENWMCNIndicatorTypeNone; |
|
74 iNetworkInfo.iMCNName = KNullDesC; |
|
75 iNetworkInfo.iSPName = KNullDesC; |
|
76 iNetworkInfo.iServiceProviderNameDisplayReq = RMobilePhone::KDisplaySPNNotRequired; |
|
77 iNetworkInfo.iNPName = KNullDesC; |
|
78 iNetworkInfo.iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHighestPriority; |
|
79 iNetworkInfo.iOperatorNameInfo.iName = KNullDesC; |
|
80 iNetworkInfo.iNoServerMode = ENWNotRegisteredOutOfRange; |
|
81 iNetworkInfo.iVoicePrivacyStatus = ENWVoicePrivacyStatusUnknown; |
|
82 iNetworkInfo.iPLMNField = KNullDesC; |
|
83 #ifdef RD_PHONE_NG |
|
84 iNetworkInfo.iSelectionSetting = ENWNetworkSelectionUnknown; |
|
85 #endif // RD_PHONE_NG |
|
86 |
|
87 NWLOGSTRING( KNWOBJECT, |
|
88 "NW: CNWMessageHandler::CNWMessageHandler() End" ); |
|
89 } |
|
90 // ---------------------------------------------------------------------------- |
|
91 // CNWMessageHandler::BaseConstructL |
|
92 // Symbian 2nd phase constructor can leave. |
|
93 // ---------------------------------------------------------------------------- |
|
94 // |
|
95 void CNWMessageHandler::BaseConstructL() |
|
96 { |
|
97 NWLOGSTRING( KNWOBJECT, |
|
98 "NW: CNWMessageHandler::BaseConstructL() Begin" ); |
|
99 |
|
100 // initialise internal network info |
|
101 iInterNetworkInfo.iSubscriberId = KNullDesC; |
|
102 iInterNetworkInfo.iCellId = 0; |
|
103 iInterNetworkInfo.iLac = 0; |
|
104 iInterNetworkInfo.iAreaKnown = ETrue; |
|
105 |
|
106 //Connect ETel server |
|
107 NWLOGSTRING( KNWREQOUT, |
|
108 "NW: CNWMessageHandler::ConstructL > rtelserver::connect" ); |
|
109 User::LeaveIfError( iServer.Connect( 128 ) ); |
|
110 |
|
111 // Load ETel TSY module |
|
112 NWLOGSTRING( KNWREQOUT, |
|
113 "NW: CNWMessageHandler::ConstructL > rtelserver::loadphonemodule" ); |
|
114 User::LeaveIfError( iServer.LoadPhoneModule( KMmTsyModuleName ) ); |
|
115 |
|
116 // Set this session to receive detailed errors |
|
117 NWLOGSTRING( KNWREQOUT, |
|
118 "NW: CNWMessageHandler::ConstructL > rtelserver::\ |
|
119 setextendederrorgranularity" ); |
|
120 User::LeaveIfError( iServer.SetExtendedErrorGranularity( |
|
121 RTelServer::EErrorExtended )); |
|
122 |
|
123 //This function opens a phone subsession by name, |
|
124 //and starts the modem initialisation process. |
|
125 NWLOGSTRING( KNWREQOUT, |
|
126 "NW: CNWMessageHandler::ConstructL > rmobilephone::open" ); |
|
127 User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName ) ); |
|
128 |
|
129 //This function opens a phone subsession by name, |
|
130 //and starts the modem initialisation process. |
|
131 NWLOGSTRING( KNWREQOUT, |
|
132 "NW: CNWMessageHandler::ConstructL > rmmcustomapi::open" ); |
|
133 User::LeaveIfError( iCustomAPI.Open( iPhone ) ); |
|
134 |
|
135 // Create CNWNetworkCurrentNetworkMonitor object |
|
136 // and insert it to monitor container. |
|
137 CNWNetworkCurrentNetworkMonitor* tempCurrentNetworkMonitor = |
|
138 CNWNetworkCurrentNetworkMonitor::NewL( *this, |
|
139 iPhone, |
|
140 iNetworkInfo, |
|
141 iCustomAPI, |
|
142 iInterNetworkInfo ); |
|
143 |
|
144 CleanupStack::PushL( tempCurrentNetworkMonitor ); |
|
145 User::LeaveIfError( iMonitorContainer.Insert( |
|
146 tempCurrentNetworkMonitor, |
|
147 KNWNetworkMonitorCurrent ) ); |
|
148 |
|
149 CleanupStack::Pop( tempCurrentNetworkMonitor ); |
|
150 |
|
151 // Create CNWNetworkModeMonitor object and insert it to monitor container. |
|
152 CNWNetworkModeMonitor* tempNetworkModeMonitor = |
|
153 CNWNetworkModeMonitor::NewL( *this, iPhone, iNetworkInfo, iCustomAPI ); |
|
154 CleanupStack::PushL( tempNetworkModeMonitor ); |
|
155 |
|
156 User::LeaveIfError( iMonitorContainer.Insert( |
|
157 tempNetworkModeMonitor, |
|
158 KNWNetworkMonitorMode ) ); |
|
159 |
|
160 CleanupStack::Pop( tempNetworkModeMonitor ); |
|
161 |
|
162 // Create CNWNetworkRegistrationStatusMonitor object |
|
163 // and insert it to monitor container. |
|
164 CNWNetworkRegistrationStatusMonitor* tempNetworkRegMonitor = |
|
165 CNWNetworkRegistrationStatusMonitor::NewL( |
|
166 *this, iPhone, iNetworkInfo, iCustomAPI ); |
|
167 |
|
168 CleanupStack::PushL( tempNetworkRegMonitor ); |
|
169 |
|
170 User::LeaveIfError( iMonitorContainer.Insert( |
|
171 tempNetworkRegMonitor, |
|
172 KNWNetworkMonitorRegistration ) ); |
|
173 |
|
174 CleanupStack::Pop( tempNetworkRegMonitor ); |
|
175 // Create NetworkProviderName command |
|
176 iNetworkProviderNameCommand = CNWNetworkProviderNameCommand::NewL( *this, |
|
177 iCustomAPI, |
|
178 iNetworkInfo ); |
|
179 |
|
180 #ifdef RD_PHONE_NG |
|
181 // Create CNWNetworkSelectionSettingMonitor object |
|
182 // and insert it to monitor container. |
|
183 CNWNetworkSelectionSettingMonitor* tempNetworkSelectionSettingMonitor = |
|
184 CNWNetworkSelectionSettingMonitor::NewL( |
|
185 *this, iPhone, iNetworkInfo, iCustomAPI ); |
|
186 CleanupStack::PushL( tempNetworkSelectionSettingMonitor ); |
|
187 |
|
188 User::LeaveIfError( iMonitorContainer.Insert( |
|
189 tempNetworkSelectionSettingMonitor, |
|
190 KNWNetworkMonitorSettingSelection ) ); |
|
191 |
|
192 CleanupStack::Pop( tempNetworkSelectionSettingMonitor ); |
|
193 #endif |
|
194 // Create SubscriberIdCommand command |
|
195 iSubscriberIdCommand = CNWSubscriberIdCommand::NewL( |
|
196 *this, iPhone, iInterNetworkInfo ); |
|
197 |
|
198 // Create ProgrammableOperatorLogo command |
|
199 iProgrammableOperatorNameCommand = |
|
200 new ( ELeave ) CNWProgrammableOperatorNameCommand( |
|
201 *this, iCustomAPI, iNetworkInfo ); |
|
202 |
|
203 // Create ServiceProviderName handler |
|
204 iServiceProviderNameCommand = |
|
205 new ( ELeave ) CNWServiceProviderNameCommand( |
|
206 *this, iPhone, iNetworkInfo ); |
|
207 |
|
208 // Start initialising network handling module. |
|
209 iMonitorContainer[ KNWNetworkMonitorRegistration ]->Initialise(); |
|
210 |
|
211 NWLOGSTRING( KNWOBJECT, |
|
212 "NW: CNWMessageHandler::BaseConstructL() End" ); |
|
213 } |
|
214 |
|
215 |
|
216 // Destructor |
|
217 EXPORT_C CNWMessageHandler::~CNWMessageHandler() |
|
218 { |
|
219 NWLOGSTRING( KNWOBJECT, |
|
220 "NW: CNWMessageHandler::~CNWMessageHandler() Begin" ); |
|
221 |
|
222 delete iNetworkProviderNameCommand; |
|
223 delete iSubscriberIdCommand; |
|
224 delete iServiceProviderNameCommand; |
|
225 delete iProgrammableOperatorNameCommand; |
|
226 |
|
227 // This deletes all monitors. |
|
228 iMonitorContainer.ResetAndDestroy( ); |
|
229 |
|
230 iCustomAPI.Close(); |
|
231 iPhone.Close(); |
|
232 if ( iServer.Handle() ) |
|
233 { |
|
234 iServer.UnloadPhoneModule( KMmTsyModuleName ); |
|
235 iServer.Close(); |
|
236 } |
|
237 |
|
238 NWLOGSTRING( KNWOBJECT, |
|
239 "NW: CNWMessageHandler::~CNWMessageHandler() End" ); |
|
240 } |
|
241 |
|
242 // ---------------------------------------------------------------------------- |
|
243 // CNWMessageHandler::SendMessage |
|
244 // Reroutes messages to the Client object |
|
245 // The function controls the starting of the monitors other than registration |
|
246 // status monitor.Other monitors are starter when registration status message |
|
247 // is received and phone has not been registered. |
|
248 // (other items were commented in a header). |
|
249 // ---------------------------------------------------------------------------- |
|
250 // |
|
251 EXPORT_C void CNWMessageHandler::SendMessage( |
|
252 MNWMessageObserver::TNWMessages aMessage ) // send message |
|
253 { |
|
254 NWLOGSTRING( KNWMESOUT, |
|
255 "NW: CNWMessageHandler::SendMessage() Begin"); |
|
256 |
|
257 if ( aMessage == MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange ) |
|
258 { |
|
259 if ( !iIsRegistered && iNetworkInfo.iRegistrationStatus != |
|
260 ENWNotRegisteredSearching ) |
|
261 { |
|
262 // Start other monitors only after we are successfully |
|
263 // registered to network. |
|
264 NWLOGSTRING( KNWMESOUT, |
|
265 "NW: CNWMessageHandler::SendMessage Start monitors"); |
|
266 iIsRegistered = ETrue; |
|
267 #ifdef RD_PHONE_NG |
|
268 iMonitorContainer[ KNWNetworkMonitorSettingSelection ]->Initialise(); |
|
269 #endif // RD_PHONE_NG |
|
270 iMonitorContainer[ KNWNetworkMonitorCurrent ]->Initialise(); |
|
271 iMonitorContainer[ KNWNetworkMonitorMode ]->Initialise(); |
|
272 } |
|
273 |
|
274 // If terminal is registered to network get serviceprovidername |
|
275 // else clean serviceprovidername information. |
|
276 if ( iNetworkInfo.iRegistrationStatus == ENWRegisteredOnHomeNetwork || |
|
277 iNetworkInfo.iRegistrationStatus == ENWRegisteredRoaming ) |
|
278 { |
|
279 // Start command querys |
|
280 iSubscriberIdCommand->IssueRequest(); |
|
281 iNetworkProviderNameCommand->IssueRequest(); |
|
282 iServiceProviderNameCommand->IssueRequest(); |
|
283 iProgrammableOperatorNameCommand->IssueRequest(); |
|
284 } |
|
285 else |
|
286 { |
|
287 iNetworkInfo.iSPName = KNullDesC; |
|
288 // Invalidate programmable name in TNWInfo |
|
289 iMessageObserver.HandleNetworkMessage( |
|
290 MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ); |
|
291 } |
|
292 } |
|
293 else if ( aMessage == MNWMessageObserver::ENWMessageNetworkInfoChange ) |
|
294 { |
|
295 if ( iPreviousStatus != iNetworkInfo.iStatus ) |
|
296 { |
|
297 // Invalidate programmable name in TNWInfo |
|
298 iMessageObserver.HandleNetworkMessage( |
|
299 MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ); |
|
300 iPreviousStatus = iNetworkInfo.iStatus; |
|
301 } |
|
302 iProgrammableOperatorNameCommand->IssueRequest(); |
|
303 } |
|
304 else if ( aMessage == MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ) |
|
305 { |
|
306 iProgrammableOperatorNameCommand->IssueRequest(); |
|
307 } |
|
308 else if ( aMessage == MNWMessageObserver::ENWMessageNetworkProviderNameUpdating ) |
|
309 { |
|
310 iNetworkProviderNameCommand->IssueRequest(); |
|
311 } |
|
312 else if ( aMessage == MNWMessageObserver::ENWMessageServiceProviderNameUpdating ) |
|
313 { |
|
314 iServiceProviderNameCommand->IssueRequest(); |
|
315 iServiceProviderNameCommand->SetAllowSendMessage( ETrue ); |
|
316 } |
|
317 else if ( aMessage == MNWMessageObserver::ENWMessageServiceProviderNameChange ) |
|
318 { |
|
319 HandleUpdateReadingStatus( ESPNEFRead, ETrue ); |
|
320 } |
|
321 else if ( aMessage == MNWMessageObserver::ENWMessageNetworkProviderNameChange ) |
|
322 { |
|
323 HandleUpdateReadingStatus( ENPNEFRead, ETrue ); |
|
324 } |
|
325 else if ( aMessage == MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange ) |
|
326 { |
|
327 HandleUpdateReadingStatus( EProgEFRead, ETrue ); |
|
328 } |
|
329 else if ( aMessage == MNWMessageObserver::ENWMessageAllowRefresh ) |
|
330 { |
|
331 iServiceProviderNameCommand->SetAllowSendMessage( EFalse ); |
|
332 } |
|
333 |
|
334 |
|
335 #ifdef TEF_LOGGING_ENABLED |
|
336 TPtrC messageName = GetNameByMessage( aMessage ); |
|
337 NWLOGSTRING2( KNWINT, |
|
338 "NW: CNWMessageHandler::SendMessage, messageName=%s", |
|
339 messageName.Ptr( ) ); |
|
340 #endif |
|
341 if ( aMessage != MNWMessageObserver::ENWMessageAllowRefresh ) |
|
342 { |
|
343 iMessageObserver.HandleNetworkMessage( aMessage ); |
|
344 } |
|
345 |
|
346 NWLOGSTRING( KNWMESOUT, |
|
347 "NW: CNWMessageHandler::SendMessage() End"); |
|
348 } |
|
349 |
|
350 #ifdef TEF_LOGGING_ENABLED |
|
351 |
|
352 // ----------------------------------------------------------------------------- |
|
353 // CNWMessageHandler::GetNameByMessage |
|
354 // Return message name, given the id of message. |
|
355 // ----------------------------------------------------------------------------- |
|
356 // |
|
357 TPtrC CNWMessageHandler::GetNameByMessage( |
|
358 MNWMessageObserver::TNWMessages aMessage ) const |
|
359 { |
|
360 switch ( aMessage ) |
|
361 { |
|
362 case MNWMessageObserver::ENWMessageNetworkIndicatorChange: |
|
363 return _L("ENWMessageNetworkIndicatorChange"); |
|
364 case MNWMessageObserver::ENWMessageNetworkInfoChange: |
|
365 return _L("ENWMessageNetworkInfoChange"); |
|
366 case MNWMessageObserver::ENWMessageNetworkModeChange: |
|
367 return _L("ENWMessageNetworkModeChange"); |
|
368 case MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange: |
|
369 return _L("ENWMessageNetworkRegistrationStatusChange"); |
|
370 case MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange: |
|
371 return _L("ENWMessageProgrammableOperatorInfoChange"); |
|
372 case MNWMessageObserver::ENWMessageNetworkProviderNameChange: |
|
373 return _L("ENWMessageNetworkProviderNameChange"); |
|
374 case MNWMessageObserver::ENWMessageServiceProviderNameChange: |
|
375 return _L("ENWMessageServiceProviderNameChange"); |
|
376 case MNWMessageObserver::ENWMessageNetworkCellReselection: |
|
377 return _L("ENWMessageNetworkCellReselection"); |
|
378 case MNWMessageObserver::ENWMessageNetworkConnectionFailure: |
|
379 return _L("ENWMessageNetworkConnectionFailure"); |
|
380 case MNWMessageObserver::ENWMessageCurrentCellInfoMessage: |
|
381 return _L("ENWMessageCurrentCellInfoMessage"); |
|
382 case MNWMessageObserver::ENWMessageCurrentHomeZoneMessage: |
|
383 return _L("ENWMessageCurrentHomeZoneMessage"); |
|
384 case MNWMessageObserver::ENWMessageNetworkEmergencyMode: |
|
385 return _L("ENWMessageNetworkEmergencyMode"); |
|
386 case MNWMessageObserver::ENWMessageVoicePrivacyStatusChange: |
|
387 return _L("ENWMessageVoicePrivacyStatusChange"); |
|
388 case MNWMessageObserver::ENWMessageStartSystemSearchRequestCompleteOk: |
|
389 return _L("ENWMessageStartSystemSearchRequestCompleteOk"); |
|
390 case MNWMessageObserver::ENWMessageStartSystemSearchRequestCompleteFail: |
|
391 return _L("ENWMessageStartSystemSearchRequestCompleteFail"); |
|
392 case MNWMessageObserver::ENWMessageStopProtocolStackRequestCompleteOk: |
|
393 return _L("ENWMessageStopProtocolStackRequestCompleteOk"); |
|
394 case MNWMessageObserver::ENWMessageStopProtocolStackRequestCompleteFail: |
|
395 return _L("ENWMessageStopProtocolStackRequestCompleteFail"); |
|
396 case MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating: |
|
397 return _L("ENWMessageProgrammableOperatorInfoUpdating"); |
|
398 case MNWMessageObserver::ENWMessageNetworkProviderNameUpdating: |
|
399 return _L("ENWMessageNetworkProviderNameUpdating"); |
|
400 case MNWMessageObserver::ENWMessageServiceProviderNameUpdating: |
|
401 return _L("ENWMessageServiceProviderNameUpdating"); |
|
402 default: |
|
403 NWLOGSTRING2( KNWINT, |
|
404 "NW: CNWMessageHandler::GetNameByMessage, unknown message = %d", |
|
405 static_cast<TInt>( aMessage ) ); |
|
406 return _L("Unknown message"); |
|
407 } //lint !e788 |
|
408 } |
|
409 #endif // Help function for logging. |
|
410 |
|
411 |
|
412 // ---------------------------------------------------------------------------- |
|
413 // CNWMessageHandler::HandleSubscriberIdChange |
|
414 // Empty implementation for Handle Subscriber Id Change |
|
415 // ---------------------------------------------------------------------------- |
|
416 // |
|
417 void CNWMessageHandler::HandleSubscriberIdChange() |
|
418 { |
|
419 NWLOGSTRING( KNWOBJECT, |
|
420 "NW: CNWMessageHandler::HandleSubscriberIdChange() Called"); |
|
421 } |
|
422 |
|
423 // ---------------------------------------------------------------------------- |
|
424 // CNWMessageHandler::SendMessage |
|
425 // Reroutes error messages to the Client object. |
|
426 // ---------------------------------------------------------------------------- |
|
427 // |
|
428 void CNWMessageHandler::SendErrorMessage( |
|
429 MNWMessageObserver::TNWOperation aOperation, |
|
430 TInt aErrorCode ) |
|
431 { |
|
432 NWLOGSTRING3( KNWMESOUT, |
|
433 "NW: CNWMessageHandler::SendErrorMessage() Begin,\ |
|
434 aOperation = %d, aErrorCode = %d ", |
|
435 aOperation, aErrorCode ); |
|
436 |
|
437 if ( aOperation == MNWMessageObserver::ENWGetNetworkProviderName ) |
|
438 { |
|
439 HandleUpdateReadingStatus( ENPNEFRead, ETrue ); |
|
440 } |
|
441 else if ( aOperation == MNWMessageObserver:: ENWGetProgrammableOperatorName ) |
|
442 { |
|
443 HandleUpdateReadingStatus( EProgEFRead, ETrue ); |
|
444 } |
|
445 else if ( aOperation == MNWMessageObserver::ENWGetServiceProviderName ) |
|
446 { |
|
447 HandleUpdateReadingStatus( ESPNEFRead, ETrue ); |
|
448 } |
|
449 |
|
450 iMessageObserver.HandleNetworkError( aOperation, aErrorCode ); |
|
451 |
|
452 NWLOGSTRING( KNWMESOUT, |
|
453 "NW: CNWMessageHandler::SendMessage() End"); |
|
454 } |
|
455 |
|
456 // ---------------------------------------------------------------------------- |
|
457 // CNWMessageHandler::HandleUpdateReadingStatus |
|
458 // Empty implementation for Handle SIM Reading status Change |
|
459 // ---------------------------------------------------------------------------- |
|
460 // |
|
461 void CNWMessageHandler::HandleUpdateReadingStatus( |
|
462 const TNWRead& /*aElementFile*/, TBool /*aReadStatus*/ ) |
|
463 { |
|
464 NWLOGSTRING( KNWOBJECT, |
|
465 "NW: CNWMessageHandler::HandleUpdateReadingStatus() Called"); |
|
466 } |
|
467 // End of File |