/*

* Copyright (c) 2006 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:  Network session handling (login, logout, etc.)

*

*/

// INCLUDE FILES

#include "CCASessionHandlerCmd.h"

#include "ChatDebugPrint.h"

#include "MCAImpsFundClient.h"

#include "CCAEngine.h"

#include "mcagroupmanagerinterface.h"

#include "MCAContactLists.h"

#include "MCAPresence.h"

#include "CAPresenceManager.h"

#include "MCAStoredContact.h"

#include "MCAStoredContacts.h"

#include "CCAStorageManagerFactory.h"

#include "ImpsCSPAllErrors.h"

#include "MCASettings.h"

#include "MCAChatInterface.h"

#include "MCAContactFetchObserver.h"

#include "MCAAccessInterface.h"

#include "mcaservicestateobserver.h"

#include "MCABackgroundTaskObserver.h"

#include "SServerPrefers.h"

#include "impsbuilddefinitions.h"

#include <bautils.h>

#include <ChatNG.rsg>

#include <cimpspresenceconnectionuing.h>

#include <cimpsconnuiclntfilteredpreseventnotifierng.h>

#include <CIMPSSAPSettingsStore.h>

#include <CIMPSSAPSettings.h>

#include <CIMPSSAPSettingsList.h>

#include <CWVSettingsUINGDialog.h>

#include <WVSettingsSharedDataNG.h>

#include <bldvariant.hrh>

#include <centralrepository.h>

#include <IMPSServiceSettingsUINGInternalCRKeys.h>

#include <aknenv.h>

#include <MProfileEngine.h>

#include <MProfile.h>

#include <Profile.hrh>

#include <impspresenceconnectionuiconstsng.h>

#include <CPEngNWSessionSlotID2.h>

#include <CPEngNWSessionSlot2.h>

#include <eikenv.h>

#include <e32property.h>

#include <StringLoader.h>

#include "IMUtils.h"

#include "IMDialogUtils.h"

#include "IMNoteMapper.h"

#include "CCACommandManagerFactory.h"

#include "CCACommandManager.h"

#include "MCALoginPC.h"

#include "MCAProcessManager.h"

#include "MCASettingsPC.h"

#include "MCAConversationPC.h"

#include "MCAUiLoginCmdCB.h"

// The Settings have been moved to Cenrep (also retained in the Resource file)

// so the enums for keys and central repository header is added here

#include 	"VariantKeys.h"

// CONSTANTS

// defines whether first login to server has been done

_LIT( KIMFirstLoginToServer, "IMFirstLoginToServer" );

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

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

// CCASessionHandlerCmd::CCASessionHandlerCmd

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

// might leave.

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

//

CCASessionHandlerCmd::CCASessionHandlerCmd(

    MCAProcessManager& aProcessManager,

    MCAUiLoginCmdCB& aUiLoginCmdCB )

        : iLastState( EIMPSPresenceServiceUnknownEvent ),

        iPresenceInitializationSuccesfull( EFalse ),

        iIsContactFetchDone( EFalse ),

        iProcessManager( aProcessManager ),

        iUiLoginCmdCB( aUiLoginCmdCB ),

        iBackgroundTaskRunning( ETrue )

    {

    }

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

// CCASessionHandlerCmd::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCASessionHandlerCmd::ConstructL()

    {

    iProfileApi = CreateProfileEngineL();

    iConnUI = CIMPSPresenceConnectionUi::NewL( EIMPSConnClientIM );

    iConnUIEventNotifier = CIMPSConnUiClntFilteredPresEventNotifier::NewL(

                               EIMPSConnClientIM );

    iConnUIEventNotifier->AddObserverL( this );

    iConnUIEventNotifier->StartL();

    iUiLoginCmdCB.SetStatusPaneIconsL();

    MCAPresence* presence = CAPresenceManager::InstanceL();

    if ( IsLoggedIn() )

        // If already logged in, just update engine state and fetch contact lists

        {

        iBackgroundTaskRunning = EFalse;

        // we can ignore the returnvalue here,

        // since the member variable is set inside anyway

        NetworkSessionSlotIDL();

        TRAPD( err, presence->InitializePresenceAPIL( *iSessionSlotID ) );

        // ATM only occasion for this to fail is that PEC has not fully

        // synchronized contact lists. We will get online event when the

        // lists are in sync.

        if ( err == KErrNone )

            {

            iPresenceInitializationSuccesfull = ETrue;

            TBool redraw( GetServicesL() );

            iUiLoginCmdCB.SetIMPSServices( iImpsServices, ETrue, redraw );

            // make sure chat has been constructed before notifying

            // the engine. if we're logged in, IMPS server should be up,

            // so this is fast

            iUiLoginCmdCB.FinalizeChatConstructionL();

            NotifyEngineL( ELoggedIn, iSessionSlotID );

            iUiLoginCmdCB.CaptureEventsL();

            // Idle loop for starting default list selection

            delete iSelectIdle;

            iSelectIdle = NULL;

            iSelectIdle = CIdle::NewL( CActive::EPriorityIdle );

            iSelectIdle->Start( TCallBack( BackgroundSelect, this ) );

            // set variated settings

            TRAPD( err, UpdateDefaultSettingsL() );

            if ( err != KErrNone ) // Signal user about error

                {

                CActiveScheduler::Current()->Error( err );

                }

            // Store current logged in SAP as previous

            CIMPSSAPSettings* temp = CurrentSAPLC();

            iPreviousSAP = temp;    // Take ownership

            CleanupStack::Pop( temp );

            }

        }

    else

        {

#ifndef CHAT_UNIT_TEST

        // Idle loop for starting login sequence login

        iIdle = CIdle::NewL( CActive::EPriorityIdle );

        iIdle->Start( TCallBack( BackgroundTasks, this ) );

#endif

        }

    }

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

// CCASessionHandlerCmd::NewL

// Two-phased constructor.

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

//

CCASessionHandlerCmd* CCASessionHandlerCmd::NewL(

    MCAProcessManager& aProcessManager,

    MCAUiLoginCmdCB& aUiLoginCmdCB )

    {

    CCASessionHandlerCmd* self = new( ELeave ) CCASessionHandlerCmd(

        aProcessManager,

        aUiLoginCmdCB );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCASessionHandlerCmd::~CCASessionHandlerCmd()

    {

    if ( iProfileApi )

        {

        iProfileApi->Release();

        }

    if ( iConnUIEventNotifier )

        {

        iConnUIEventNotifier->Stop();

        iConnUIEventNotifier->RemoveObserver( this );

        }

    delete iConnUIEventNotifier;

    delete iConnUI;

    delete iIdle;

    delete iSelectIdle;

    delete iPreviousSAP;

    delete iSessionSlotID;

    iFetchObservers.Close();

    iServiceStateObservers.Close();

    }

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

// CCASessionHandlerCmd::IsLoggedIn

// (other items were commented in a header).

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

//

TBool CCASessionHandlerCmd::IsLoggedIn() const

    {

    TBool returnValue( EFalse );

    if ( IsOfflineProfileOn() )

        {

        CHAT_DP( D_CHAT_LIT(

                     "CCASessionHandlerCmd::IsLoggedIn, offline profile is ON, returning %d" ),

                 returnValue );

        return returnValue;

        }

    TRAPD( err, returnValue = iConnUI->LoggedInL( EIMPSConnClientIM ) );

    if ( err )

        {

        returnValue = EFalse;

        }

    CHAT_DP( D_CHAT_LIT( "CCASessionHandlerCmd::IsLoggedIn returning %d" ),

             returnValue );

    // if there are no slots in the system then we get KErrNotFound

    // and we don't show it to the user

    if ( ( err != KErrNone ) && ( err != KErrNotFound ) )

        {

        CActiveScheduler::Current()->Error( err );

        }

    return returnValue;

    }

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

// CCASessionHandlerCmd::LoginL

// (other items were commented in a header).

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

//

TBool CCASessionHandlerCmd::LoginL( TBool aAskConfirmation /*= ETrue */,

                                    TBool aIsStartupLogin /*= EFalse */ )

    {

    CHAT_DP_TXT( "CCASessionHandlerCmd::LoginL started" );

    if ( IsOfflineProfileOn() )

        {

        IMDialogUtils::DisplayInformationNoteL( R_QTN_OFFLINE_NOT_POSSIBLE );

        return EFalse;

        }

    if ( IsLoggedIn() )

        {

        return ETrue; // already logged in

        }

    TInt ret( EAknSoftkeyNo );

    if ( aAskConfirmation )

        {

        TPtrC serverNamePtr( KNullDesC );

        CIMPSSAPSettings* sap = NULL;

        if ( iPreviousSAP )

            {

            // get current SAP

            CIMPSSAPSettings* currentSap = CurrentSAPLC();

            delete iPreviousSAP;

            // replace the previous SAP

            iPreviousSAP = currentSap;

            CleanupStack::Pop( currentSap );

            // get the last logged in server name

            serverNamePtr.Set( iPreviousSAP->SAPName() );

            }

        else

            {

            sap = CurrentSAPLC();

            serverNamePtr.Set( sap->SAPName() );

            CleanupStack::PopAndDestroy( sap );

            }

        // load the promp from lOC file + server name

        HBufC* prompt = StringLoader::LoadLC( R_QTN_CHAT_CONNECTION_NEEDED_TO,

                                              serverNamePtr );

        ret = IMDialogUtils::DisplayQueryDialogL( R_GENERIC_YES_NO_CONFIRMATION_QUERY,

                                                  *prompt );

        CleanupStack::PopAndDestroy( prompt );

        }

    if ( ( ret == EAknSoftkeyOk ) || ( ret == EAknSoftkeyYes )

         || ( !aAskConfirmation ) )

        {

        // check if we have valid server data

        if ( iUiLoginCmdCB.CheckCurrentServerDataL() )

            {

            CHAT_DP_TXT(

                "PEC is offline, server data is ok -> execute PEC login" );

            TIMPSLoginType loginType = LoginType(); // default to manual login

            if ( ( loginType == EIMPSAAConnectionStart ||

                   loginType == EIMPSApplicationLaunch ) &&

                 !aIsStartupLogin )

                {

                //defaulting to manual if login type is automatic

                // since in this case we want to see the server selection dialog

                loginType = EIMPSManualLogin;

                }

            if ( loginType != EIMPSAAConnectionStart )

                {

                iLogging = ETrue;

                if ( aAskConfirmation )

                    {

                    loginType = EIMPSApplicationLaunch;

                    }

                CPEngNWSessionSlotID2* tempID = CPEngNWSessionSlotID2::NewL();

                delete iSessionSlotID;

                iSessionSlotID = tempID;

                iCurrentLoginIsFirst = EFalse;

                TInt err = KErrNone;

                if ( aAskConfirmation && iPreviousSAP )

                    {

                    //  user want to connect to last logged in server

                    // hence pass the previous sap

                    // aAskConfirmation will allow to load from sapsetting any more

                    err = iConnUI->LoginL( EIMPSConnClientIM, loginType,

                                           *iSessionSlotID, this , iPreviousSAP, aAskConfirmation ) ;

                    }

                else

                    {

                    err = iConnUI->LoginL( EIMPSConnClientIM, loginType,

                                           *iSessionSlotID, this ) ;

                    }

                CHAT_DP( D_CHAT_LIT(

                             "CCASessionHandlerCmd::LoginL, \

                            iConnUI->LoginL( EIMPSConnClientIM, %d ) returned %d" ),

                         loginType, err );

                iLogging = EFalse;

                if ( err == KErrNone )

                    {

                    TBool redraw( GetServicesL() );

                    iUiLoginCmdCB.SetIMPSServices( iImpsServices, ETrue, redraw );

                    NotifyEngineL( EServerPrefers );

                    iUiLoginCmdCB.SetStatusPaneIconsL();

                    CCAStorageManagerFactory::ContactListInterfaceL()->

                    ResetContactLists();

                    CIMPSSAPSettings* sap = CurrentSAPLC();

                    MCASettingsPC* settingsPC = iProcessManager.GetSettingsInterface();

                    settingsPC->SetDefaultSapL( sap );

                    CleanupStack::PopAndDestroy( sap );

                    }

                iUiLoginCmdCB.FinalizeChatConstructionL();

                }

            }

        }

    iUiLoginCmdCB.ReleaseCapturingL();

    return IsLoggedIn(); // Login was perhaps done

    }

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

// CCASessionHandlerCmd::LogoutL

// (other items were commented in a header).

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

//

TBool CCASessionHandlerCmd::LogoutL()

    {

    CHAT_DP_TXT( "CCASessionHandlerCmd::LogoutL started" );

    //Check for background tasks completion.

    //only then give perform logout

    if ( !IsBackgroundTaskPendingL() )

        {

        iProcessManager.GetEngine()->CancelAllRequests();

        return DoLogoutL();

        }

    CHAT_DP_TXT( "CCASessionHandler::LogoutL done" );

    return IsLoggedIn();

    }

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

// CCASessionHandlerCmd::LogoutL

// (other items were commented in a header).

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

TBool CCASessionHandlerCmd::DoLogoutL()

    {

    CHAT_DP_TXT( "CCASessionHandlerCmd::DoLogoutL started" );

    MCAStoredContacts* contactsInterface =

        CCAStorageManagerFactory::ContactListInterfaceL();

    contactsInterface->SetContactListLock( ETrue );

    iLogging = ETrue;

    // this should not even be called if there is no session slot ID

    if ( iSessionSlotID )

        {

        iProcessManager.GetLogInInterface()->LogoutL();

        iConnUI->LogoutL( *iSessionSlotID, this );

        delete iSessionSlotID;

        iSessionSlotID = NULL;

        }

    iLogging = EFalse;

    iCurrentLoginIsFirst = EFalse;

    NotifyEngineL( ELoggingOut );

    contactsInterface->SetContactListLock( EFalse );

    CHAT_DP_TXT( "CCASessionHandlerCmd::DoLogoutL done" );

    return IsLoggedIn();

    }

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

// CCASessionHandler::HandleSapAccessEventEventL

// (other items were commented in a header).

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

//

void CCASessionHandlerCmd::HandleSapAccessEventEventL( const TDesC& aServerName,

                                                       const TDesC& aServerURL,

                                                       MIMPSConnProcessUi* aConnProcessUi )

    {

    iUiLoginCmdCB.HandleSapAccessEventEventL( aServerName, aServerURL,

                                              aConnProcessUi );

    }

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

// CCASessionHandlerCmd::IsSupported

// (other items were commented in a header).

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

//

TBool CCASessionHandlerCmd::IsSupported( TSupportedFeature aFeature )

    {

    switch ( aFeature )

        {

        case EGroup :

            {

            return iImpsServices.iGroupFeat.FeatureSupported();

            }

        case ESearch :

            {

            return iImpsServices.iFundamentalFeat.FunctionSupported(

                       KPEngFFSearchFunction );

            }

        case EInvite :

            {

            return iImpsServices.iFundamentalFeat.FunctionSupported(

                       KPEngFFInviteFunction );

            }

        case EBlock :

            {