diff -r 000000000000 -r ff3b6d0fd310 networkhandling/networkhandlingengine/NetworkHandlingSrc/CNWMessageHandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkhandling/networkhandlingengine/NetworkHandlingSrc/CNWMessageHandler.cpp Tue Feb 02 01:11:09 2010 +0200 @@ -0,0 +1,467 @@ +/* +* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: This module contains the implementation of CNWMessageHandler +* +*/ + + + +// INCLUDE FILES +#include "NWHandlingEngine.h" +#include "CNWMessageHandler.h" +#include "CNWNetworkCurrentNetworkMonitor.h" +#include "CNWNetworkRegistrationStatusMonitor.h" +#include "CNWProgrammableOperatorNameCommand.h" +#include "CNWServiceProviderNameCommand.h" +#include "CNWNetworkModeMonitor.h" +#include "CNWNetworkProviderNameCommand.h" +#include "CNWSubscriberIdCommand.h" +#include "NWLogger.h" +#ifdef RD_PHONE_NG +#include "cnwnetworkselectionsettingmonitor.h" +#endif // RD_PHONE_NG +// CONSTANTS +const TInt KNWNetworkMonitorCurrent = 0; +const TInt KNWNetworkMonitorMode = 1; +const TInt KNWNetworkMonitorRegistration = 2; +#ifdef RD_PHONE_NG +const TInt KNWNetworkMonitorSettingSelection = 3; +#endif // RD_PHONE_NG + + +// ============================ MEMBER FUNCTIONS ============================== + +// ---------------------------------------------------------------------------- +// CNWMessageHandler::CNWMessageHandler +// C++ default constructor can NOT contain any code, that +// might leave. +// ---------------------------------------------------------------------------- +// +EXPORT_C CNWMessageHandler::CNWMessageHandler( + CNWSession& aNetworkData, + MNWMessageObserver& aMessageObserver, + TNWInfo& aNWInfo ) + : iNetworkData( aNetworkData ), + iMessageObserver( aMessageObserver ), + iNetworkInfo( aNWInfo ) + { + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::CNWMessageHandler() Begin" ); + + // initialise current network info + iNetworkInfo.iRegistrationStatus = ENWRegistrationUnknown; + iNetworkInfo.iNetworkMode = ENWModeUnknown; + iNetworkInfo.iStatus = ENWStatusUnknown; + iNetworkInfo.iCountryCode = KNullDesC; + iNetworkInfo.iNetworkId = KNullDesC; + iNetworkInfo.iDisplayTag = KNullDesC; + iNetworkInfo.iShortName = KNullDesC; + iNetworkInfo.iLongName = KNullDesC; + iNetworkInfo.iViagIndicatorType = ENWViagIndicatorTypeNone; + iNetworkInfo.iViagTextTag = KNullDesC; + iNetworkInfo.iMCNIndicatorType = ENWMCNIndicatorTypeNone; + iNetworkInfo.iMCNName = KNullDesC; + iNetworkInfo.iSPName = KNullDesC; + iNetworkInfo.iServiceProviderNameDisplayReq = RMobilePhone::KDisplaySPNNotRequired; + iNetworkInfo.iNPName = KNullDesC; + iNetworkInfo.iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHighestPriority; + iNetworkInfo.iOperatorNameInfo.iName = KNullDesC; + iNetworkInfo.iNoServerMode = ENWNotRegisteredOutOfRange; + iNetworkInfo.iVoicePrivacyStatus = ENWVoicePrivacyStatusUnknown; + iNetworkInfo.iPLMNField = KNullDesC; +#ifdef RD_PHONE_NG + iNetworkInfo.iSelectionSetting = ENWNetworkSelectionUnknown; +#endif // RD_PHONE_NG + + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::CNWMessageHandler() End" ); + } +// ---------------------------------------------------------------------------- +// CNWMessageHandler::BaseConstructL +// Symbian 2nd phase constructor can leave. +// ---------------------------------------------------------------------------- +// +void CNWMessageHandler::BaseConstructL() + { + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::BaseConstructL() Begin" ); + + // initialise internal network info + iInterNetworkInfo.iSubscriberId = KNullDesC; + iInterNetworkInfo.iCellId = 0; + iInterNetworkInfo.iLac = 0; + iInterNetworkInfo.iAreaKnown = ETrue; + + //Connect ETel server + NWLOGSTRING( KNWREQOUT, + "NW: CNWMessageHandler::ConstructL > rtelserver::connect" ); + User::LeaveIfError( iServer.Connect( 128 ) ); + + // Load ETel TSY module + NWLOGSTRING( KNWREQOUT, + "NW: CNWMessageHandler::ConstructL > rtelserver::loadphonemodule" ); + User::LeaveIfError( iServer.LoadPhoneModule( KMmTsyModuleName ) ); + + // Set this session to receive detailed errors + NWLOGSTRING( KNWREQOUT, + "NW: CNWMessageHandler::ConstructL > rtelserver::\ + setextendederrorgranularity" ); + User::LeaveIfError( iServer.SetExtendedErrorGranularity( + RTelServer::EErrorExtended )); + + //This function opens a phone subsession by name, + //and starts the modem initialisation process. + NWLOGSTRING( KNWREQOUT, + "NW: CNWMessageHandler::ConstructL > rmobilephone::open" ); + User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName ) ); + + //This function opens a phone subsession by name, + //and starts the modem initialisation process. + NWLOGSTRING( KNWREQOUT, + "NW: CNWMessageHandler::ConstructL > rmmcustomapi::open" ); + User::LeaveIfError( iCustomAPI.Open( iPhone ) ); + + // Create CNWNetworkCurrentNetworkMonitor object + // and insert it to monitor container. + CNWNetworkCurrentNetworkMonitor* tempCurrentNetworkMonitor = + CNWNetworkCurrentNetworkMonitor::NewL( *this, + iPhone, + iNetworkInfo, + iCustomAPI, + iInterNetworkInfo ); + + CleanupStack::PushL( tempCurrentNetworkMonitor ); + User::LeaveIfError( iMonitorContainer.Insert( + tempCurrentNetworkMonitor, + KNWNetworkMonitorCurrent ) ); + + CleanupStack::Pop( tempCurrentNetworkMonitor ); + + // Create CNWNetworkModeMonitor object and insert it to monitor container. + CNWNetworkModeMonitor* tempNetworkModeMonitor = + CNWNetworkModeMonitor::NewL( *this, iPhone, iNetworkInfo, iCustomAPI ); + CleanupStack::PushL( tempNetworkModeMonitor ); + + User::LeaveIfError( iMonitorContainer.Insert( + tempNetworkModeMonitor, + KNWNetworkMonitorMode ) ); + + CleanupStack::Pop( tempNetworkModeMonitor ); + + // Create CNWNetworkRegistrationStatusMonitor object + // and insert it to monitor container. + CNWNetworkRegistrationStatusMonitor* tempNetworkRegMonitor = + CNWNetworkRegistrationStatusMonitor::NewL( + *this, iPhone, iNetworkInfo, iCustomAPI ); + + CleanupStack::PushL( tempNetworkRegMonitor ); + + User::LeaveIfError( iMonitorContainer.Insert( + tempNetworkRegMonitor, + KNWNetworkMonitorRegistration ) ); + + CleanupStack::Pop( tempNetworkRegMonitor ); + // Create NetworkProviderName command + iNetworkProviderNameCommand = CNWNetworkProviderNameCommand::NewL( *this, + iCustomAPI, + iNetworkInfo ); + +#ifdef RD_PHONE_NG + // Create CNWNetworkSelectionSettingMonitor object + // and insert it to monitor container. + CNWNetworkSelectionSettingMonitor* tempNetworkSelectionSettingMonitor = + CNWNetworkSelectionSettingMonitor::NewL( + *this, iPhone, iNetworkInfo, iCustomAPI ); + CleanupStack::PushL( tempNetworkSelectionSettingMonitor ); + + User::LeaveIfError( iMonitorContainer.Insert( + tempNetworkSelectionSettingMonitor, + KNWNetworkMonitorSettingSelection ) ); + + CleanupStack::Pop( tempNetworkSelectionSettingMonitor ); +#endif + // Create SubscriberIdCommand command + iSubscriberIdCommand = CNWSubscriberIdCommand::NewL( + *this, iPhone, iInterNetworkInfo ); + + // Create ProgrammableOperatorLogo command + iProgrammableOperatorNameCommand = + new ( ELeave ) CNWProgrammableOperatorNameCommand( + *this, iCustomAPI, iNetworkInfo ); + + // Create ServiceProviderName handler + iServiceProviderNameCommand = + new ( ELeave ) CNWServiceProviderNameCommand( + *this, iPhone, iNetworkInfo ); + + // Start initialising network handling module. + iMonitorContainer[ KNWNetworkMonitorRegistration ]->Initialise(); + + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::BaseConstructL() End" ); + } + + +// Destructor +EXPORT_C CNWMessageHandler::~CNWMessageHandler() + { + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::~CNWMessageHandler() Begin" ); + + delete iNetworkProviderNameCommand; + delete iSubscriberIdCommand; + delete iServiceProviderNameCommand; + delete iProgrammableOperatorNameCommand; + + // This deletes all monitors. + iMonitorContainer.ResetAndDestroy( ); + + iCustomAPI.Close(); + iPhone.Close(); + if ( iServer.Handle() ) + { + iServer.UnloadPhoneModule( KMmTsyModuleName ); + iServer.Close(); + } + + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::~CNWMessageHandler() End" ); + } + +// ---------------------------------------------------------------------------- +// CNWMessageHandler::SendMessage +// Reroutes messages to the Client object +// The function controls the starting of the monitors other than registration +// status monitor.Other monitors are starter when registration status message +// is received and phone has not been registered. +// (other items were commented in a header). +// ---------------------------------------------------------------------------- +// +EXPORT_C void CNWMessageHandler::SendMessage( + MNWMessageObserver::TNWMessages aMessage ) // send message + { + NWLOGSTRING( KNWMESOUT, + "NW: CNWMessageHandler::SendMessage() Begin"); + + if ( aMessage == MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange ) + { + if ( !iIsRegistered && iNetworkInfo.iRegistrationStatus != + ENWNotRegisteredSearching ) + { + // Start other monitors only after we are successfully + // registered to network. + NWLOGSTRING( KNWMESOUT, + "NW: CNWMessageHandler::SendMessage Start monitors"); + iIsRegistered = ETrue; +#ifdef RD_PHONE_NG + iMonitorContainer[ KNWNetworkMonitorSettingSelection ]->Initialise(); +#endif // RD_PHONE_NG + iMonitorContainer[ KNWNetworkMonitorCurrent ]->Initialise(); + iMonitorContainer[ KNWNetworkMonitorMode ]->Initialise(); + } + + // If terminal is registered to network get serviceprovidername + // else clean serviceprovidername information. + if ( iNetworkInfo.iRegistrationStatus == ENWRegisteredOnHomeNetwork || + iNetworkInfo.iRegistrationStatus == ENWRegisteredRoaming ) + { + // Start command querys + iSubscriberIdCommand->IssueRequest(); + iNetworkProviderNameCommand->IssueRequest(); + iServiceProviderNameCommand->IssueRequest(); + iProgrammableOperatorNameCommand->IssueRequest(); + } + else + { + iNetworkInfo.iSPName = KNullDesC; + // Invalidate programmable name in TNWInfo + iMessageObserver.HandleNetworkMessage( + MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ); + } + } + else if ( aMessage == MNWMessageObserver::ENWMessageNetworkInfoChange ) + { + if ( iPreviousStatus != iNetworkInfo.iStatus ) + { + // Invalidate programmable name in TNWInfo + iMessageObserver.HandleNetworkMessage( + MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ); + iPreviousStatus = iNetworkInfo.iStatus; + } + iProgrammableOperatorNameCommand->IssueRequest(); + } + else if ( aMessage == MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating ) + { + iProgrammableOperatorNameCommand->IssueRequest(); + } + else if ( aMessage == MNWMessageObserver::ENWMessageNetworkProviderNameUpdating ) + { + iNetworkProviderNameCommand->IssueRequest(); + } + else if ( aMessage == MNWMessageObserver::ENWMessageServiceProviderNameUpdating ) + { + iServiceProviderNameCommand->IssueRequest(); + iServiceProviderNameCommand->SetAllowSendMessage( ETrue ); + } + else if ( aMessage == MNWMessageObserver::ENWMessageServiceProviderNameChange ) + { + HandleUpdateReadingStatus( ESPNEFRead, ETrue ); + } + else if ( aMessage == MNWMessageObserver::ENWMessageNetworkProviderNameChange ) + { + HandleUpdateReadingStatus( ENPNEFRead, ETrue ); + } + else if ( aMessage == MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange ) + { + HandleUpdateReadingStatus( EProgEFRead, ETrue ); + } + else if ( aMessage == MNWMessageObserver::ENWMessageAllowRefresh ) + { + iServiceProviderNameCommand->SetAllowSendMessage( EFalse ); + } + + + #ifdef TEF_LOGGING_ENABLED + TPtrC messageName = GetNameByMessage( aMessage ); + NWLOGSTRING2( KNWINT, + "NW: CNWMessageHandler::SendMessage, messageName=%s", + messageName.Ptr( ) ); + #endif + if ( aMessage != MNWMessageObserver::ENWMessageAllowRefresh ) + { + iMessageObserver.HandleNetworkMessage( aMessage ); + } + + NWLOGSTRING( KNWMESOUT, + "NW: CNWMessageHandler::SendMessage() End"); + } + +#ifdef TEF_LOGGING_ENABLED + +// ----------------------------------------------------------------------------- +// CNWMessageHandler::GetNameByMessage +// Return message name, given the id of message. +// ----------------------------------------------------------------------------- +// +TPtrC CNWMessageHandler::GetNameByMessage( + MNWMessageObserver::TNWMessages aMessage ) const + { + switch ( aMessage ) + { + case MNWMessageObserver::ENWMessageNetworkIndicatorChange: + return _L("ENWMessageNetworkIndicatorChange"); + case MNWMessageObserver::ENWMessageNetworkInfoChange: + return _L("ENWMessageNetworkInfoChange"); + case MNWMessageObserver::ENWMessageNetworkModeChange: + return _L("ENWMessageNetworkModeChange"); + case MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange: + return _L("ENWMessageNetworkRegistrationStatusChange"); + case MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange: + return _L("ENWMessageProgrammableOperatorInfoChange"); + case MNWMessageObserver::ENWMessageNetworkProviderNameChange: + return _L("ENWMessageNetworkProviderNameChange"); + case MNWMessageObserver::ENWMessageServiceProviderNameChange: + return _L("ENWMessageServiceProviderNameChange"); + case MNWMessageObserver::ENWMessageNetworkCellReselection: + return _L("ENWMessageNetworkCellReselection"); + case MNWMessageObserver::ENWMessageNetworkConnectionFailure: + return _L("ENWMessageNetworkConnectionFailure"); + case MNWMessageObserver::ENWMessageCurrentCellInfoMessage: + return _L("ENWMessageCurrentCellInfoMessage"); + case MNWMessageObserver::ENWMessageCurrentHomeZoneMessage: + return _L("ENWMessageCurrentHomeZoneMessage"); + case MNWMessageObserver::ENWMessageNetworkEmergencyMode: + return _L("ENWMessageNetworkEmergencyMode"); + case MNWMessageObserver::ENWMessageVoicePrivacyStatusChange: + return _L("ENWMessageVoicePrivacyStatusChange"); + case MNWMessageObserver::ENWMessageStartSystemSearchRequestCompleteOk: + return _L("ENWMessageStartSystemSearchRequestCompleteOk"); + case MNWMessageObserver::ENWMessageStartSystemSearchRequestCompleteFail: + return _L("ENWMessageStartSystemSearchRequestCompleteFail"); + case MNWMessageObserver::ENWMessageStopProtocolStackRequestCompleteOk: + return _L("ENWMessageStopProtocolStackRequestCompleteOk"); + case MNWMessageObserver::ENWMessageStopProtocolStackRequestCompleteFail: + return _L("ENWMessageStopProtocolStackRequestCompleteFail"); + case MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating: + return _L("ENWMessageProgrammableOperatorInfoUpdating"); + case MNWMessageObserver::ENWMessageNetworkProviderNameUpdating: + return _L("ENWMessageNetworkProviderNameUpdating"); + case MNWMessageObserver::ENWMessageServiceProviderNameUpdating: + return _L("ENWMessageServiceProviderNameUpdating"); + default: + NWLOGSTRING2( KNWINT, + "NW: CNWMessageHandler::GetNameByMessage, unknown message = %d", + static_cast( aMessage ) ); + return _L("Unknown message"); + } //lint !e788 + } +#endif // Help function for logging. + + +// ---------------------------------------------------------------------------- +// CNWMessageHandler::HandleSubscriberIdChange +// Empty implementation for Handle Subscriber Id Change +// ---------------------------------------------------------------------------- +// +void CNWMessageHandler::HandleSubscriberIdChange() + { + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::HandleSubscriberIdChange() Called"); + } + +// ---------------------------------------------------------------------------- +// CNWMessageHandler::SendMessage +// Reroutes error messages to the Client object. +// ---------------------------------------------------------------------------- +// +void CNWMessageHandler::SendErrorMessage( + MNWMessageObserver::TNWOperation aOperation, + TInt aErrorCode ) + { + NWLOGSTRING3( KNWMESOUT, + "NW: CNWMessageHandler::SendErrorMessage() Begin,\ + aOperation = %d, aErrorCode = %d ", + aOperation, aErrorCode ); + + if ( aOperation == MNWMessageObserver::ENWGetNetworkProviderName ) + { + HandleUpdateReadingStatus( ENPNEFRead, ETrue ); + } + else if ( aOperation == MNWMessageObserver:: ENWGetProgrammableOperatorName ) + { + HandleUpdateReadingStatus( EProgEFRead, ETrue ); + } + else if ( aOperation == MNWMessageObserver::ENWGetServiceProviderName ) + { + HandleUpdateReadingStatus( ESPNEFRead, ETrue ); + } + + iMessageObserver.HandleNetworkError( aOperation, aErrorCode ); + + NWLOGSTRING( KNWMESOUT, + "NW: CNWMessageHandler::SendMessage() End"); + } + +// ---------------------------------------------------------------------------- +// CNWMessageHandler::HandleUpdateReadingStatus +// Empty implementation for Handle SIM Reading status Change +// ---------------------------------------------------------------------------- +// +void CNWMessageHandler::HandleUpdateReadingStatus( + const TNWRead& /*aElementFile*/, TBool /*aReadStatus*/ ) + { + NWLOGSTRING( KNWOBJECT, + "NW: CNWMessageHandler::HandleUpdateReadingStatus() Called"); + } +// End of File