/*

* Copyright (c) 2004 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:  Offers the always online functionality for the Presence Engine

*                and the Chat application

*

*/

// INCLUDE FILES

#include "CIMPSAlwaysOnlinePluginImp.h"

#include "CPEngAOPluginTimer.h"

#include "CPEngAOCallObserver.h"

#include "IMPSCommonUiDebugPrint.h"

//#include "PresenceErrors.h"

#include "CIMPSAlwaysOnlineScheduler.h"

#include "CPEngAONwStatusObserver.h"

#include "cimpsconnuiconnectionmodenotifierng.h"

#include "cimpspresenceaaconnectionng.h"

#include "CIMPSSharedDataFactory.h"

#include "MIMPSSharedData.h"

#include "CIMPSReconnectNoteHandler.h"

#include "IMPSUIDDefs.h"

#include "impspresenceconnectionuiconstsng.h"

#include <PEngAOPluginNG.rsg>

#include <flogger.h>

#include <PEngPresenceEngineConsts2.h>

#include <avkon.hrh>

#include <errorui.h>

#include <e32property.h>    // RProperty

#include <APGCLI.H>

#include <APACMDLN.H>

#include <aknglobalmsgquery.h>

#include <bautils.h>

#include "cpengaodialogmonitor.h"

#include "impscommonuibuilddefinitions.h"

// CONSTANTS

// after first 12 connection tries is shown global note for continuation

// if user accepts continuation then 8 new tries and after that note

// is shown again user accepts again then 8 new tries and so on....

const TInt KFirstReconnectionRetryCycleLength( 12 );

const TInt KRestReconnectionRetryCyclesLength( 8 );

//wait time after changing from offline to not offline state, in microseconds

const TInt KWaitTimeFromOfflineToNotOffline = 22000000;

// the wait times are from IMPS Service Settings UI specification and they are

// in minutes. They are also relative to the previously waited, not

// absolute wait times. For first fife tries are defined values and after that

// reconnection is tried after 15 minutes intervals

const TInt KMaxNumberOfDefinedWaitTimes( 5 );

const TInt KLoginWaitTime[KMaxNumberOfDefinedWaitTimes] = { 0, 2, 3, 5, 5 };

const TInt KDefaultLoginWaitTime = 15;

_LIT_SECURITY_POLICY_PASS( KIMPSSharedReadPolicy );

_LIT_SECURITY_POLICY_PASS( KIMPSSharedWritePolicy );

_LIT( KAOPluginResourceFile, "PENGAOPluginNG.rsc" );

_LIT( KAOPluginResourcePath, "\\Resource\\" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::CIMPSAlwaysOnlinePluginImp

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CIMPSAlwaysOnlinePluginImp::CIMPSAlwaysOnlinePluginImp() :

        iNetworkOpsAllowed( ETrue ),

//iPreviousEvent( EPEngPresenceServiceSAPChanged ),

        iLoginCount( 1 ), // first attempt

        iPluginState( EIMPSAOPluginRunning ),

        iRoaming( EFalse ),

        iScheduledLoginOk( EFalse ),

        iUserControlledConnection( EFalse ),

        iEventInQueue( EFalse ),

        iQueuedLogoutIsScheduledLogout( EFalse ),

        iCurServerDisconnectDenied( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CIMPSAlwaysOnlinePluginImp::ConstructL()

    {

    iAutoLogin = iKeys.LoginManualEnum();

    // client for notice setting changes

    iSettingChangesNotifier =

        CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL( this,

                                                            KIMPSServSettNotifyUid );

    // create shared data client

    iSharedDataServiceSettings =

        CIMPSSharedDataFactory::CreatePermanentKeyHandlerL( this,

                                                            KIMPSServSettUid );

    iNwObserver = CPEngAONwStatusObserver::NewL( *this );

    // Create monitor for roam ing warning dialog

    iDlgMonitor = CPEngAODialogMonitor::NewL( *this );

    User::LeaveIfError( iFs.Connect() );

    TFileName resourceFileName;

    resourceFileName.Zero();

    TFileName drivePath;

    Dll::FileName( drivePath );

    resourceFileName.Append( TParsePtrC( drivePath ).Drive() );

    resourceFileName.Append( KAOPluginResourcePath() );

    resourceFileName.Append( KAOPluginResourceFile );

    if ( resourceFileName.Length() > 0 )

        {

        // when baflutils gets an empty string, it returns "C:",

        // which breaks things

        BaflUtils::NearestLanguageFile( iFs, resourceFileName );

        }

    iResFile.OpenL( iFs, resourceFileName );

    iResFile.ConfirmSignatureL();

    }

// -----------------------------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CIMPSAlwaysOnlinePluginImp* CIMPSAlwaysOnlinePluginImp::NewL()

    {

    CIMPSAlwaysOnlinePluginImp* self = new( ELeave ) CIMPSAlwaysOnlinePluginImp();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CIMPSAlwaysOnlinePluginImp::~CIMPSAlwaysOnlinePluginImp()

    {

    FreeMemory();

    delete iSettingChangesNotifier;

    delete iSharedDataServiceSettings;

    delete iNwObserver;

    delete iRoamingQueryText;

    delete iRoamingQueryTitle;

    if (	iGlobalMsgQuery )

        {

        iGlobalMsgQuery->CancelMsgQuery();

        }

    delete iGlobalMsgQuery;

    delete iDlgMonitor;

    }

// ---------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::DoLogin

// Logs out from the wv server

// ---------------------------------------------------------

//

void CIMPSAlwaysOnlinePluginImp::DoLogin()

    {

    IMPSCUI_DP_FUNC_ENTER( "DoLogin" );

    // if already in doing login state or

    // if the call is active, just return when the call ends, we get a notify->

    // just return (a possible leave can be ignored)

    if ( iCallObserver->CallActive( this ) )

        {

        // if call is active, this is set as the call observer

        IMPSCUI_DP_TXT( "Call is active, cannot do login currently" );

        return;

        }

    else if ( iPluginState == EIMPSAOPluginDoingLogin )

        {

        // emptying event queue,

        // because is currently doing login, and we

        // want to be in logged state after login is done

        iEventInQueue = EFalse;

        return;

        }

    else if ( iPluginState == EIMPSAOPluginDoingLogout )

        {

        // currently doing logout, adding login action to

        // event queue

        iEventInQueue = ETrue;

        return;

        }

    // start login procedure and set correct state

    iPluginState = EIMPSAOPluginDoingLogin;

    iReconnectNoteHandler->CancelNoteShowing( this );

    IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSAlwaysOnlinePluginImp::DoLogin try[%d]" ), iLoginCount );

    TInt retVal( KErrNone );

    TInt err( KErrNone );

    iTimeBeforeLoginTry.HomeTime();

#ifdef DEBUG

    TDateTime loginTime;

    loginTime = iTimeBeforeLoginTry.DateTime();

    IMPSCUI_DP_TXT( "Time before login try: " );

    IMPSCUI_DP( D_IMPSCUI_LIT( "year [%d] " ), loginTime.Year() );

    // +1 added to get human readable form of day and month on debug print

    IMPSCUI_DP( D_IMPSCUI_LIT( "day [%d], month [%d]" ), loginTime.Day() + 1,

                loginTime.Month() + 1 );

    IMPSCUI_DP( D_IMPSCUI_LIT( "hour [%d], minu [%d]" ), loginTime.Hour(),

                loginTime.Minute() );

#endif

    TRAP( err, retVal =  iConnectionUI->LoginL( EIMPSConnClientIM ) );

    iPluginState = EIMPSAOPluginRunning;

    // regardless of the result of login, if there came a logout event during

    // the login, call DoLogout

    if ( iEventInQueue )

        {

        iEventInQueue = EFalse;

        DoLogout( iQueuedLogoutIsScheduledLogout );

        iQueuedLogoutIsScheduledLogout = EFalse;

        return;

        }

    // handle leaves with memory related errors

    CheckMemoryErrors( err );

    if ( err < KErrNone )

        {

        IMPSCUI_DP( D_IMPSCUI_LIT( "LoginL leaved with code [%d]" ), err );

        IMPSCUI_DP_TXT( "All leaves are handled as retval KErrCouldNotConnect" );

        // if the LoginL-call leaves set the return value to normal

        // return value when connection could not be made, to get reconnect

        // later working.

        retVal = KErrCouldNotConnect;

        }

    switch ( retVal )

        {

        case KErrAlreadyExists: // fallthrough

        case KErrNone:

            {

            // Login succeeded, reset the plugin states and counts

            IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSAlwaysOnlinePluginImp::DoLogin successful try[%d]" ), iLoginCount + 1 );

            Reset();

            break;

            }

        case KErrNotFound: // fallthrough

        case KErrArgument:

        case KErrNotSupported:

            {

            // wrong password, don't try to relogin, ConnectionUI shows the note

            Reset();

            // reset because we can't retry the login if the username and / or

            // password are incorrect

            break;

            }

        case KErrAccessDenied: // fallthrough

        case KErrGeneral:

        case KErrCouldNotConnect:

            {

            // login failed with some network failure (time out or other network error) ->

            // wait and try again, show confirmation query if needed

            if ( iLoginCount == KFirstReconnectionRetryCycleLength )

                {

                iReconnectNoteHandler->ShowNote( this );

                }

            else if ( ( iLoginCount > KFirstReconnectionRetryCycleLength ) &&

                      ( ( ( iLoginCount - KFirstReconnectionRetryCycleLength )

                          % KRestReconnectionRetryCyclesLength ) == 0

                      )

                    )

                {

                iReconnectNoteHandler->ShowNote( this );

                }

            else

                {

                StartWaiting();

                iLoginCount++;

                }

            break;

            }

        case KErrCouldNotDisconnect:

            {

            // there was connection to different server than default

            // and user denied disconnecting

            iCurServerDisconnectDenied = ETrue;

            }

        break;

        default:

            {

            // something else, undefined return value

            // these errors don't affect reconnection functionality

            // For just in case checking memory related errors

            CheckMemoryErrors( retVal );

            break;

            }

        }

    }

// ---------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::DoLogout

// Logs out from the wv server

// ---------------------------------------------------------

//

void CIMPSAlwaysOnlinePluginImp::DoLogout( TBool aIsScheduledLogout /* = EFalse */ )

    {

    IMPSCUI_DP_FUNC_ENTER( "DoLogout" );

    // do logout only if we are logged in

    TBool loggedIn( EFalse );

    TInt err( KErrNone );

    TRAP( err, loggedIn = iConnectionUI->LoggedInL( EIMPSConnClientIM ) );

    // Checking memory errors

    CheckMemoryErrors( err );

    if ( ( !loggedIn ) || err )

        {

        // not logged in just return

        // errors are handled as not logged in.

        return;

        }

    else if ( iPluginState == EIMPSAOPluginDoingLogout )

        {

        // emptying event queue,

        // because is currently doing logout, and we

        // want to be in logged out state after logout is done

        iEventInQueue = EFalse;

        iQueuedLogoutIsScheduledLogout = EFalse;

        return;

        }

    else if ( iPluginState == EIMPSAOPluginDoingLogin )

        {

        // currently doing login, adding logout action to

        // event queue

        iEventInQueue = ETrue;

        iQueuedLogoutIsScheduledLogout = aIsScheduledLogout;

        return;

        }

    iPluginState = EIMPSAOPluginDoingLogout;

    TInt retVal( KErrNone );

    TRAP( err, retVal = iConnectionUI->LogoutL( EIMPSConnClientIM,

                                                aIsScheduledLogout ) );

    // checking memory related errors

    // other errors are  ignored, because want only forward most

    // importand errors to framework

    CheckMemoryErrors( err );

    if ( retVal == KErrAccessDenied )

        {

        iCurServerDisconnectDenied = ETrue;

        }

    iPluginState = EIMPSAOPluginRunning;

    // regardless of the result of logout, if there came a login event during

    // the login, call DoLogout

    if ( iEventInQueue )

        {

        iEventInQueue = EFalse;

        iQueuedLogoutIsScheduledLogout = EFalse;

        DoLogin();

        }

    }

// ---------------------------------------------------------

// CIMAlwaysOnlinePlugin::CheckPluginNeed()

// Checks if the autologin option is set.

// ---------------------------------------------------------

//

TBool CIMPSAlwaysOnlinePluginImp::CheckPluginNeed()

    {

    IMPSCUI_DP_FUNC_ENTER( "CheckPluginNeed" );

    TInt readValue( KErrCouldNotConnect ); // initialize to an error value

    TInt err( iSharedDataServiceSettings->GetIntKey( iKeys.LoginTypeKey(), readValue ) );

    if ( ( err != KErrNone ) ||

         ( readValue < iKeys.MinLoginTypeEnum()  ) ||

         ( readValue > iKeys.MaxLoginTypeEnum() ) )

        {

        return EFalse;

        }

    iAutoLogin = readValue;

    IMPSCUI_DP_FUNC_DONE( "CheckPluginNeed" );

    if ( iShowRoamingWarning )

        {

        return ETrue;

        }

    else

        {

        return ( ( readValue == iKeys.LoginAutoAlwaysEnum() ) ||

                 ( readValue == iKeys.LoginAutoInHomeNWEnum() ) );

        }

    }

void CIMPSAlwaysOnlinePluginImp::SetShowRoamingWarning( TBool aShowRoamWarning )

    {

    iShowRoamingWarning = aShowRoamWarning;

    }

// ---------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::CheckAllConnectionVariables

// Checks the plugin variables and makes a login or logout

// if needed.

// ---------------------------------------------------------

//

void CIMPSAlwaysOnlinePluginImp::CheckAllConnectionVariables()

    {

    IMPSCUI_DP_FUNC_ENTER( "CheckAllConnectionVariablesL" );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iNetworkOpsAllowed = %d " ), iNetworkOpsAllowed );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iUserControlledConnection = %d " ), iUserControlledConnection );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iAutoLogin = %d " ), iAutoLogin );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iScheduledLoginOk = %d " ), iScheduledLoginOk );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iCurServerDisconnectDenied = %d " ), iCurServerDisconnectDenied );

    IMPSCUI_DP( D_IMPSCUI_LIT( "iRoaming = %d " ), iRoaming );

    // network operations not allowed

    if ( !IsNetworkOperationsAllowed() )

        {

        IMPSCUI_DP_TXT( "NetworkOps NOT allowed" );

        IMPSCUI_DP_FUNC_DONE( "CheckAllConnectionVariablesL" );

        return;

        }

    // autogin not set

    // -> don't do anything

    else if ( ( iAutoLogin != iKeys.LoginAutoAlwaysEnum() ) &&

              ( iAutoLogin != iKeys.LoginAutoInHomeNWEnum() ) )

        {

        IMPSCUI_DP_TXT( "autologin NOT set" );

        IMPSCUI_DP_FUNC_DONE( "CheckAllConnectionVariablesL" );

        return;

        }

    // we already know that autologin is set -> no need to check that

    // check if scheduled login not ok

    else if ( !iScheduledLoginOk )

        {

        IMPSCUI_DP_TXT( "Scheduled Login NOT on" );

        DoLogout( ETrue );

        }

    else if ( ( iAutoLogin == iKeys.LoginAutoAlwaysEnum() ) ||

              ( !iRoaming && ( iAutoLogin == iKeys.LoginAutoInHomeNWEnum() ) ) )

        {

        // If its Alwayslogin, roaing and roaing warning flag is enabled

        // then ask user if wants to login

        if ( ( iAutoLogin == iKeys.LoginAutoAlwaysEnum() ) &&

             iRoaming &&

             iShowRoamingWarning )

            {

            TBool isUserLoggedIn( EFalse );

            TRAP_IGNORE( isUserLoggedIn = IsUserLoggedInL() );

            // If the dialog is not displaying now then show it

            if ( !( iDlgMonitor &&

                    iDlgMonitor->IsActive() &&

                    !isUserLoggedIn ) )

                {

                TBool isRoamingDlgShown( EFalse );

                RProperty roaming;

                TInt error = roaming.Get( KIMPSConnUiTemporaryUid, EIMPSSharedKeysRoamingDlgShown, isRoamingDlgShown );

                if ( !isRoamingDlgShown && !error )

                    {

                    TRAP_IGNORE( HandleRoamingL() );

                    }

                }

            }

        else

            {

            DoLogin();

            TBool isLoggedIn( EFalse );

            TRAP_IGNORE( isLoggedIn = iConnectionUI->LoggedInL( EIMPSConnClientIM ) );

            if ( iIsToLogoutForRoaming && isLoggedIn )

                {

                iIsToLogoutForRoaming = EFalse;

                DoLogout();

                }

            }

        }

    // check the roaing is on and we are in autologin state

    else if ( ( iAutoLogin == iKeys.LoginAutoInHomeNWEnum() ) && iRoaming )

        {

        DoLogout();

        }

    IMPSCUI_DP_FUNC_DONE( "CheckAllConnectionVariablesL" );

    }

// ---------------------------------------------------------

// CIMPSAlwaysOnlinePluginImp::HandlePresenceEventL

// Handles the presence event change