/*
* 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 <aifweventhandler.h>
#include <ai3xmlui.rsg>
#include <AknQueryDialog.h>
#include <AknGlobalNote.h>
#include <StringLoader.h>

// User includes
#include <activeidle2domaincrkeys.h>
#include "onlineofflinehelper.h"
#include "xmluicontroller.h"
#include "appui.h"

// Constants
const TInt KOfflineProfileId( 5 );

using namespace AiXmlUiController;

// ============================ 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 repository
    iUiCtl.SettingsRepository().Set(  KAIWebStatus, iFlags.IsSet( EOnline ) ); 
    
    iCurrentNwStatus = ENWRegistrationUnknown;    
    }
      
// ----------------------------------------------------------------------------
// COnlineOfflineHelper::~COnlineOfflineHelper
// ----------------------------------------------------------------------------
//
COnlineOfflineHelper::~COnlineOfflineHelper() 
    {
    delete iHandler;
    delete iSession;
    // Whether the user choice EOnline should be stored in cenrep ?
    }

// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ShowOnlineItem
// ----------------------------------------------------------------------------
//
TBool COnlineOfflineHelper::ShowOnlineItem() const
    {
    if ( iFlags.IsSet( EUtilizeOnline ) )
    	{
    	TInt value ( KErrNotFound );
    	if ( iUiCtl.SettingsRepository().Get(  KAIWebStatus, value ) == KErrNone )
    		{
    		return ( !value );
    		}
    	}
    return EFalse;
    }

// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ShowOfflineItem
// ----------------------------------------------------------------------------
//
TBool COnlineOfflineHelper::ShowOfflineItem() const
    {
    if ( iFlags.IsSet( EUtilizeOnline ) )
		{
		TInt value ( KErrNotFound );
		if ( iUiCtl.SettingsRepository().Get(  KAIWebStatus, value ) == KErrNone )
			{
			return ( value );
			}
		}
     return EFalse;
    }

// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ProcessOnlineStateL
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::ProcessOnlineStateL( 
    RPointerArray< CXnNodeAppIf >& aList )
    {
    _LIT( KOnlineOffline, "online_offline" );

    iFlags.Clear( EUtilizeOnline );
                   
    // Check if data plugins are using online_offline
    for ( TInt i = 0; i < aList.Count(); i++ )
        {
        TAiPublisherInfo info;
        
        iUiCtl.PublisherInfoL( *aList[i], info );
                         
        if( iUiCtl.FwEventHandler()->HasMenuItemL( info, KOnlineOffline() ) )
            {
            iFlags.Set( EUtilizeOnline );            
            break;                       
            }
        }    
    
    if( iFlags.IsSet( EUtilizeOnline ) )
        {
        TInt value( 0 );
        iUiCtl.SettingsRepository().Get( KAIWebStatus, value );
        
        if ( value )
        	{
            // Switch to online
        	SetOnlineL( ETrue );
        	}
        else
        	{
            // Switch to offline
        	SetOnlineL( EFalse );
        	}                
        }
    }

// ----------------------------------------------------------------------------
// COnlineOfflineHelper::ProcessOnlineStateL
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::ProcessOnlineStateL( TBool aOnline )
    {
    // User has selected online/offline item from menu
    if( iFlags.IsSet( EUtilizeOnline ) )
    	{
    	 // Don't show R_YES_NO_HS_ONLINE query as user selected online
    	 if (aOnline )
			{
			iFlags.Set( EOnline );
			// Save state
			iUiCtl.SettingsRepository().Set( KAIWebStatus, ETrue );
			// Run state change.
			iUiCtl.FwEventHandler()->ProcessStateChange( EAifwOnline  );     
			}
    	 else
    		 {
    		 iFlags.Clear( EOnline );
    		 // Save state
			 iUiCtl.SettingsRepository().Set( KAIWebStatus, EFalse );
			 // Run state change.
			 iUiCtl.FwEventHandler()->ProcessStateChange( EAifwOffline  );
    		 }
    	}
    }

// ----------------------------------------------------------------------------
// COnlineOfflineHelper::SetOnline
// ----------------------------------------------------------------------------
//
void COnlineOfflineHelper::SetOnlineL( TBool aOnline )    
    {
    
    // Save state
    iUiCtl.SettingsRepository().Set( KAIWebStatus, aOnline );

    if( aOnline )
        {
        // Run state change.
        iUiCtl.FwEventHandler()->ProcessStateChange( EAifwOnline  );        
        }
    else  
        {
		// Run state change.
		iUiCtl.FwEventHandler()->ProcessStateChange( 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:
                    if( iFlags.IsSet( EOnline ) )
                        {
                        // Process to offline state. 
                        // Don't change the user selection.
                        SetOnlineL ( EFalse );
                        // Show roaming notification
						CAknGlobalNote* note = CAknGlobalNote::NewLC();
						HBufC* msg( StringLoader::LoadLC( R_QTN_HS_AUTOMATIC_OFFLINE ) );
						 
						note->ShowNoteL( EAknGlobalInformationNote, *msg );
						CleanupStack::PopAndDestroy( 2, note ); // msg    
                        }
                    
                    iCurrentNwStatus = aNWInfo.iRegistrationStatus;
                    break;
                case ENWRegisteredOnHomeNetwork:
                	// Reset to user selection
                	SetOnlineL(iFlags.IsSet( EOnline ) );
                	
                    iCurrentNwStatus = aNWInfo.iRegistrationStatus;
                    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.
            SetOnlineL( EFalse );
            }
        else
            {
            iFlags.Clear( EOfflineProfile );
            // Reset to user selection
            SetOnlineL(iFlags.IsSet( EOnline ) );
            }
        }
    
    delete iHandler;
    iHandler = NULL;
    
    iHandler = CProfileChangeNotifyHandler::NewL( this );        
    }

 // End of file