/*
* Copyright (c) 2005-2008 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: Helper for online/offline state handling
*
*/
// System includes
#include <NetworkHandlingProxy.h>
#include <CNWSession.h>
#include <MProfileEngine.h>
#include <CProfileChangeNotifyHandler.h>
#include <ai3xmlui.rsg>
#include <AknQueryDialog.h>
#include <AknGlobalNote.h>
#include <StringLoader.h>
#include <cmmanagerkeys.h>
#include <AknGlobalConfirmationQuery.h>
#include <StringLoader.h> // StringLoader
#include <AknQueryDialog.h>
#include <ai3xmlui.rsg>
// User includes
#include <aifwstatehandler.h>
#include <aifwdefs.h>
#include <activeidle2domaincrkeys.h>
#include <hspublisherinfo.h>
#include "onlineofflinehelper.h"
#include "xmluicontroller.h"
#include "appui.h"
#include "ai3.hrh"
#include "globalqueryhandler.h"
// Constants
const TInt KOfflineProfileId( 5 );
using namespace AiXmlUiController;
#ifdef HS_NETWORK_MONITOR
#include <flogger.h>
_LIT( KLogFolder,"xnnetwork" );
_LIT( KLogDom, "networksettings.log" );
#define _LOG1( a ) RFileLogger::Write( \
KLogFolder, KLogDom, EFileLoggingModeAppend, ( a ) );
#define _LOG2( a, b ) RFileLogger::WriteFormat( \
KLogFolder, KLogDom, EFileLoggingModeAppend, ( a ), ( b ) )
#else
#define _LOG1
#define _LOG2
#endif
_LIT( KDisConnected, "disconnected");
_LIT( KConnected, "connected");
// ============================ LOCAL FUNCTIONS ==============================
// ============================ MEMBER FUNCTIONS =============================
// ---------------------------------------------------------------------------
// COnlineOfflineHelper::NewL
// ---------------------------------------------------------------------------
//
COnlineOfflineHelper* COnlineOfflineHelper::NewL( CXmlUiController& aUiCtl )
{
COnlineOfflineHelper* self = new ( ELeave )COnlineOfflineHelper( aUiCtl );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::COnlineOfflineHelper
// ----------------------------------------------------------------------------
//
COnlineOfflineHelper::COnlineOfflineHelper( CXmlUiController& aUiCtl )
: iUiCtl( aUiCtl )
{
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ConstructL
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::ConstructL()
{
//Create network handling engine session.
iSession = CreateL( *this, iInfo );
iHandler = CProfileChangeNotifyHandler::NewL( this );
MProfileEngine* engine( CreateProfileEngineL() );
if( engine->ActiveProfileId() == KOfflineProfileId )
{
iFlags.Set( EOfflineProfile );
}
engine->Release();
TInt value( 0 );
if ( iUiCtl.SettingsRepository().Get( KAIWebStatus, value ) == KErrNone )
{
if( value && iFlags.IsClear( EOfflineProfile ) )
{
iFlags.Set( EOnline );
}
}
// Update state manager
SetOnline( iFlags.IsSet( EOnline ) );
iCurrentNwStatus = ENWRegistrationUnknown;
iHomeNetwork = KErrNotFound;
iRoamingNetwork = KErrNotFound;
iNwSettingObserver = CCenRepObserver::NewL( this );
iGlobalQueryHandler = CGlobalQueryHandler::NewL(iUiCtl);
iGlobalConfirmationQuery = CAknGlobalConfirmationQuery::NewL();
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::~COnlineOfflineHelper
// ----------------------------------------------------------------------------
//
COnlineOfflineHelper::~COnlineOfflineHelper()
{
delete iHandler;
delete iSession;
delete iNwSettingObserver;
delete iGlobalQueryHandler;
delete iGlobalConfirmationQuery;
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::CurrentCellularDataUsageChangedL
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::CurrentCellularDataUsageChangedL(const TInt aValue)
{
if ( iCurrentNwStatus == ENWRegisteredOnHomeNetwork )
{
iHomeNetwork = aValue;
}
else if ( iCurrentNwStatus == ENWRegisteredRoaming )
{
iRoamingNetwork = aValue;
}
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ShowOnlineItem
// ----------------------------------------------------------------------------
//
TBool COnlineOfflineHelper::ShowOnlineItem() const
{
if ( iUiCtl.FwStateHandler()->OnlineStateInUse() )
{
TInt value ( KErrNotFound );
if ( iUiCtl.SettingsRepository().Get( KAIWebStatus, value ) == KErrNone )
{
return ( !value );
}
}
return EFalse;
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ShowOfflineItem
// ----------------------------------------------------------------------------
//
TBool COnlineOfflineHelper::ShowOfflineItem() const
{
if ( iUiCtl.FwStateHandler()->OnlineStateInUse() )
{
TInt value ( KErrNotFound );
if ( iUiCtl.SettingsRepository().Get( KAIWebStatus, value ) == KErrNone )
{
return ( value );
}
}
return EFalse;
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ProcessOnlineStateL
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::ProcessOnlineStateL( TBool aOnline )
{
// User has selected online/offline item from menu
if( iUiCtl.FwStateHandler()->OnlineStateInUse() )
{
// Don't show R_YES_NO_HS_ONLINE query as user selected online
if ( aOnline )
{
iFlags.Set( EOnline );
}
else
{
iFlags.Clear( EOnline );
}
SetOnline( aOnline );
}
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::SetOnline
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::SetOnline( TBool aOnline )
{
// Save state
iUiCtl.SettingsRepository().Set( KAIWebStatus, aOnline );
// Run state change.
iUiCtl.FwStateHandler()->ChangePluginState(
aOnline ? EAiFwOnline : EAiFwOffline );
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::HandleNetworkMessage
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::HandleNetworkMessage( const TNWMessages aMessage )
{
if ( HasNetworkInfoChanged( aMessage ) )
{
// Interpret new nw state
TRAP_IGNORE( InterpretNWMessageL( aMessage, iInfo ) );
}
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::InterpretNWMessage
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::InterpretNWMessageL( const TNWMessages aMessage,
const TNWInfo aNWInfo )
{
switch ( aMessage )
{
case MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange:
case MNWMessageObserver::ENWMessageCurrentHomeZoneMessage:
{
switch ( aNWInfo.iRegistrationStatus )
{
case ENWRegisteredRoaming:
_LOG1( _L(" Roaming Network Activated "));
iCurrentNwStatus = aNWInfo.iRegistrationStatus;
CurrentNetworkSetting();
if( ( iRoamingNetwork == ECmCellularDataUsageConfirm
|| iRoamingNetwork == ECmCellularDataUsageDisabled )
&& iFlags.IsSet( EOnline ) )
{
// Process to offline state.
// Don't change the user selection.
SetOnline( EFalse );
// Show roaming notification
CAknGlobalNote* note = CAknGlobalNote::NewLC();
HBufC* msg( StringLoader::LoadLC( R_QTN_HS_AUTOMATIC_OFFLINE ) );
note->SetSoftkeys(R_AVKON_SOFTKEYS_OK_EMPTY);
note->ShowNoteL( EAknGlobalInformationNote, *msg );
CleanupStack::PopAndDestroy( 2, note ); // msg
}
break;
case ENWRegisteredOnHomeNetwork:
_LOG1( _L(" Home Network Activated "));
iCurrentNwStatus = aNWInfo.iRegistrationStatus;
CurrentNetworkSetting();
if( iHomeNetwork == ECmCellularDataUsageAutomatic )
{
// Reset to user selection
SetOnline( iFlags.IsSet( EOnline ) );
}
break;
default:
// unknown state
iCurrentNwStatus = ENWRegistrationUnknown;
break;
}
}
}
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::HandleNetworkError
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::HandleNetworkError( const TNWOperation aOperation,
TInt /*aErrorCode*/ )
{
switch ( aOperation )
{
case MNWMessageObserver::ENWGetNetworkProviderName:
iReceivedMessageFlags |= ENetworkProviderNameReceived;
iReceivedMessageFlags &= ~ENetworkProviderNameOk;
iInfo.iNPName.Zero();
break;
case MNWMessageObserver::ENWGetProgrammableOperatorName:
iReceivedMessageFlags |= EProgrammableOperatorInfoReceived;
iReceivedMessageFlags &= ~EProgrammableOperatorInfoReceivedOk;
iInfo.iOperatorNameInfo.iName.Zero();
break;
case MNWMessageObserver::ENWGetServiceProviderName:
iReceivedMessageFlags |= EServiceProviderNameReceived;
iReceivedMessageFlags &= ~EServiceProviderNameOk;
iInfo.iServiceProviderNameDisplayReq = RMobilePhone::KDisplaySPNNotRequired;
iInfo.iSPName.Zero();
iInfo.iPLMNField.Zero();
break;
default:
break;
}
HandleNetworkMessage( TNWMessages( KErrGeneral ) );
}
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::HasNetworkInfoChanged
// ----------------------------------------------------------------------------
//
TBool COnlineOfflineHelper::HasNetworkInfoChanged( const TNWMessages aMsg )
{
TBool result( ETrue );
// pass through
if ( aMsg == MNWMessageObserver::ENWMessageCurrentHomeZoneMessage ||
aMsg == MNWMessageObserver::ENWMessageNetworkConnectionFailure ||
aMsg == MNWMessageObserver::ENWMessageCurrentCellInfoMessage ||
aMsg == MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange )
{
return result;
}
result = ( iReceivedMessageFlags != iOldReceivedMessageFlags );
if ( !result )
{
result = iInfo.iRegistrationStatus != iOldInfo.iRegistrationStatus;
}
iOldReceivedMessageFlags = iReceivedMessageFlags;
iOldInfo = iInfo;
return result;
}
// ---------------------------------------------------------------------------
// COnlineOfflineHelper::HandleActiveProfileEventL
// ---------------------------------------------------------------------------
//
void COnlineOfflineHelper::HandleActiveProfileEventL(
TProfileEvent aProfileEvent, TInt aProfileId )
{
//Profile activated or modified.
if ( aProfileEvent == EProfileNewActiveProfile )
{
if( aProfileId == KOfflineProfileId )
{
iFlags.Set( EOfflineProfile );
// Don't change the user selection.
SetOnline( EFalse );
}
else
{
iFlags.Clear( EOfflineProfile );
// Reset to user selection
SetOnline( iFlags.IsSet( EOnline ) );
}
}
delete iHandler;
iHandler = NULL;
iHandler = CProfileChangeNotifyHandler::NewL( this );
}
// ---------------------------------------------------------------------------
// COnlineOfflineHelper::CurrentNetworkSetting
// ---------------------------------------------------------------------------
//
void COnlineOfflineHelper::CurrentNetworkSetting()
{
CRepository* repository( NULL );
TRAP_IGNORE( repository = CRepository::NewL( KCRUidCmManager ) )
if ( repository )
{
TInt value( 0 );
TInt err( repository->Get( KCurrentCellularDataUsage, value ) );
if ( err == KErrNone )
{
if ( iCurrentNwStatus == ENWRegisteredRoaming )
{
iRoamingNetwork = value;
_LOG2( _L("Roaming Network Setting <%d>"), value );
}
else if ( iCurrentNwStatus == ENWRegisteredOnHomeNetwork )
{
iHomeNetwork = value;
_LOG2( _L("Home Network Setting <%d>"), value );
}
}
}
delete repository;
}
// ---------------------------------------------------------------------------
// COnlineOfflineHelper::HandleConnectionQueryL
// ---------------------------------------------------------------------------
//
void COnlineOfflineHelper::HandleConnectionQueryL( const TDesC& aConnection)
{
if ( aConnection == KDisConnected() )
{
ShowGlobalQueryL(R_QTN_HS_DISABLE_NETWORK, EFalse );
}
else if ( aConnection == KConnected() )
{
ShowGlobalQueryL(R_QTN_HS_SWITCH_ONLINE, ETrue );
}
}
// ---------------------------------------------------------------------------
// COnlineOfflineHelper::ShowGlobalQueryL
// ---------------------------------------------------------------------------
//
void COnlineOfflineHelper::ShowGlobalQueryL( TInt aResourceId, TBool aSetOnline )
{
if ( !iGlobalQueryHandler->IsActive() )
{
HBufC* confirmationText = StringLoader::LoadLC(aResourceId);
iGlobalConfirmationQuery->ShowConfirmationQueryL(
iGlobalQueryHandler->iStatus,
*confirmationText,
R_AVKON_SOFTKEYS_YES_NO);
iGlobalQueryHandler->SetOnlineParamAndActivate(aSetOnline);
CleanupStack::PopAndDestroy(); //confirmationText
}
}
// End of file