/*

* 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:  Process Component for Login,Logout

*

*/

// INCLUDE FILES

#include "CCAEngine.h"

#include "PublicEngineDefinitions.h"

#include "ImpsCSPAllErrors.h"

#include "MCASettings.h"

#include "MCAAccessInterface.h"

#include "SServerPrefers.h"

#include "impsbuilddefinitions.h"

#include "IMUtils.h"

#include <chatng.rsg>

#include <CPEngNWSessionSlotID2.h>

#include <CIMPSSAPSettingsStore.h>

#include <CIMPSSAPSettings.h>

#include <CIMPSSAPSettingsList.h>

#include <WVSettingsSharedDataNG.h>

#include <IMPSServiceSettingsUINGInternalCRKeys.h>

#include <aknenv.h>

#include <barsread.h>

#include <CPEngNWSessionSlotID2.h>

#include <CPEngNWSessionSlot2.h>

#include <cimpspresenceconnectionuing.h>

#include "CCAStorageManagerFactory.h"

#include "MCAStoredContacts.h"

#include "CAUtils.h"

#include "CCALoginPC.h"

#include "MCABackgroundTaskObserver.h"

#include "CCAMainViewArrayPC.h"

#include "MCALoginRefreshObserverPC.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"

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

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

// CCALoginPC::NewL

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

//

CCALoginPC* CCALoginPC::NewL( CCAEngine& aEngine )

    {

    CCALoginPC* self = new ( ELeave ) CCALoginPC( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCALoginPC::~CCALoginPC()

    {

    delete iLoggedUserId;

    delete iOldLoggedUserId;

    delete iMainViewArrayPC;

    if ( iLoggedInSap )

        {

        delete iLoggedInSap;

        iLoggedInSap = NULL;

        }

    if ( iRefreshObserver )

        {

        iRefreshObserver = NULL;

        }

    }

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

// CCALoginPC::CCALoginPC

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

// might leave.

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

//

CCALoginPC::CCALoginPC( CCAEngine& aEngine )

        : iEngine( aEngine )

    {

    MCAChatInterface& chatInterface = iEngine.ChatInterface();

    iFirstLogin = ETrue;

    }

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

// CCALoginPC::ConstructL

// Symbian Second Phased Constructor, contain any code that

// might leave.

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

//

void CCALoginPC::ConstructL()

    {

    MCAChatInterface& chatInterface = iEngine.ChatInterface();

    iMainViewArrayPC = CCAMainViewArrayPC::

                       NewL( iEngine, iEngine.ContactListModel(), chatInterface );

    iLoggedInSap = NULL;

    }

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

// CCALoginPC::LoginL

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

//

TBool CCALoginPC::LoginL( TNetworkState aState, CIMPSSAPSettings* aSettings,

                          CPEngNWSessionSlotID2* aSessionSlotID,

                          TPEngWVCspServicesTree2 &aImpsServices )

    {

    HBufC* accessPoint = aSessionSlotID->ServiceAddress().AllocLC();

    HBufC* userId = aSessionSlotID->UserId().AllocLC();

    TImpsCspIdentifier cspId( *accessPoint, *userId );

    TRAPD( err, iEngine.GetAccessInterface()->LoginL( cspId,

                                                      aSettings->SAPUserPassword(),

                                                      aSettings->ClientId(),

                                                      aSettings->AccessPoint(),

                                                      &aSettings->ServerAuthenticationName(),

                                                      &aSettings->ServerAuthenticationPassword() ) );

    if ( err != KErrNone )

        {

        return EFalse;

        }

    // set logged in user id

    MCASettings* settings = iEngine.GetInternalSettingsInterface();

    settings->SetValueL( MCASettings::EOwnWVUserID, *userId );

    settings->SetValueL( MCASettings::EServiceAddress, *accessPoint );

    CleanupStack::PopAndDestroy( 2, accessPoint ); // userId, accessPoint, sap

    PerformNetworkStateChangeL( aState, aSessionSlotID, aImpsServices );

    // this is deleted in the destructor and this called

    // only when the application is exited.

    // so when ever the login/logout is done each time this is created

    // but not deleted

    if ( iLoggedInSap )

        {

        delete iLoggedInSap;

        iLoggedInSap = NULL;

        }

    iLoggedInSap = CIMPSSAPSettings::NewL();

    // this was leaking, changed to NewLC()

    CIMPSPresenceConnectionUi* connUI = CIMPSPresenceConnectionUi::NewLC( EIMPSConnClientIM );

    connUI->GetLoggedInSapL( *aSessionSlotID, *iLoggedInSap );

    CleanupStack::PopAndDestroy( connUI );

    //Store the user id when logged in for the first time.

    //here the old user id an new user id will be the same on first login.

    if ( iFirstLogin )

        {

        iOldLoggedUserId = aSessionSlotID->UserId().AllocL();

        iFirstLogin = EFalse;

        iMainViewArrayPC->ResetArray( ETrue );

        iMainViewArrayPC->SetCurrentItemIndexL( ETrue );

        }

    //delete the previous login id

    delete iLoggedUserId;

    iLoggedUserId = NULL;

    //Store the currently logged in user id for every login

    iLoggedUserId = aSessionSlotID->UserId().AllocL();

    if ( FreshLoginL() )

        {

        iEngine.ChatInterface().CloseAllContainers(); //Only if fresh login

        iMainViewArrayPC->ResetArray( ETrue );

        }

    else

        {

        iMainViewArrayPC->ResetArray( EFalse );

        }

    iMainViewArrayPC->ResetGroupCountDownOnLogout();

    iMainViewArrayPC->PopulateGroupsListL();

    if ( iRefreshObserver )

        {

        iRefreshObserver->HandleLoginRefreshCompleteL();

        }

    // call back if conveversation view is active

    return ETrue;

    }

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

// CCALoginPC::PerformNetworkStateChangeL

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

//

void CCALoginPC::PerformNetworkStateChangeL( TNetworkState aState,

                                             CPEngNWSessionSlotID2* aSessionSlotID,

                                             TPEngWVCspServicesTree2 &aImpsServices )

    {

    // build up the server preferences structure (variated things to

    // pass on to the engine)

    SServerPrefers serverPrefers;

    serverPrefers.iUseGrant =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_HAVEGRANT );

    serverPrefers.iAliasUsed =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_HAVE_ALIAS );

    serverPrefers.iLocalEchoInGroup =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_LOCAL_ECHO_USED_IN_GROUP );

    serverPrefers.iReactiveAuthorization =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_REACTIVE_PRESENCE_AUTH );

    iEngine.HandleNetworkStateChangeL( aState, &aImpsServices, serverPrefers,

                                       aSessionSlotID );

    }

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

// CCALoginPC::GetArrayInterface

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

//

EXPORT_C MCAMainViewArrayPC* CCALoginPC::GetArrayInterface() const

    {

    return iMainViewArrayPC;

    }

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

// CCALoginPC::NotifyEngineForLogoutL

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

//

TBool CCALoginPC::NotifyEngineForLogoutL( TNetworkState aState,

                                          CPEngNWSessionSlotID2* aSessionSlotID,

                                          TPEngWVCspServicesTree2 &aImpsServices )

    {

    SServerPrefers serverPrefers;

    serverPrefers.iUseGrant =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_HAVEGRANT );

    serverPrefers.iAliasUsed =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_HAVE_ALIAS );

    serverPrefers.iLocalEchoInGroup =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_LOCAL_ECHO_USED_IN_GROUP );

    serverPrefers.iReactiveAuthorization =

        IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_REACTIVE_PRESENCE_AUTH );

    TRAPD( err, iEngine.HandleNetworkStateChangeL( aState, &aImpsServices, serverPrefers,

                                                   aSessionSlotID ) );

    if ( err != KErrNone )

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CCALoginPC::LogoutL

// Once engine has been fully constructed full, invoke logout on the

// AcessInterface  reference

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

//

void CCALoginPC::LogoutL()

    {

    MCAAccessInterface* accessIf = iEngine.GetAccessInterface();

    if ( accessIf )

        {

        // the interface exists only if engine had been fully constructed

        accessIf->LogoutL();

        iMainViewArrayPC->ResetArray( EFalse );

        iMainViewArrayPC->SetCurrentItemIndexL();

        }

    }

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

// CCALoginPC::CancelAllRequests

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

//

void CCALoginPC::CancelAllRequests()

    {

    iEngine.CancelAllRequests();

    }

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

// CCALoginPC::ReadyForShutdown()

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

//

TBool CCALoginPC::ReadyForShutdown()

    {

    return iEngine.ReadyForShutdown();

    }

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

// CCALoginPC::SetShowNicknameL

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

//

void CCALoginPC::SetShowNicknameL( TBool aShowNickname )

    {

    MCAStoredContacts* contacts =

        CCAStorageManagerFactory::ContactListInterfaceL();

    contacts->SetShowNickname( aShowNickname );

    }

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

// CCALoginPC::SetAliasL

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

//

void CCALoginPC::SetAliasL( const TDesC& aAlias )

    {

    CCAStorageManagerFactory::ContactListInterfaceL()->

    OwnStatus().SetAliasL( aAlias );

    }

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

// CCALoginPC::FreshLoginL

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

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

//

TBool CCALoginPC::FreshLoginL( )

    {

    if ( !iLoggedInSap )

        {

        return EFalse;

        }

    TBool isFreshLogin = EFalse;

    // check if iLoggedUserId & iOldLoggedUserId are not null;

    if ( iLoggedUserId && iOldLoggedUserId )

        {

        if ( CAUtils::NeutralCompare( *iOldLoggedUserId, *iLoggedUserId ) != 0 )

            {

            isFreshLogin = ETrue;

            if ( iOldLoggedUserId )

                {

                delete iOldLoggedUserId;

                iOldLoggedUserId = NULL;

                }

            iOldLoggedUserId = iLoggedUserId->AllocL();

            }

        else

            {

            isFreshLogin = EFalse;

            }

        }

    return isFreshLogin;

    }

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

// CCALoginPC::AddObserver

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

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

//

void CCALoginPC::AddObserver( MCALoginRefreshObserverPC *aObserver )

    {

    iRefreshObserver = aObserver;

    }

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

// CCALoginPC::RemoveObserver

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

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

//

void CCALoginPC::RemoveObserver()

    {

    iRefreshObserver = NULL;

    }

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

// CCALoginPC::RegisterGroupSyncObserver

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

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

//

void CCALoginPC::RegisterBackGroundTaskObserver( MCABackGroundTaskObserver *aObserver )

    {

    iEngine.RegisterBackGroundTaskObserver( aObserver );

    }

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

// CCALoginPC::UnRegisterGroupSyncObserver

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

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

//

void CCALoginPC::UnRegisterBackGroundTaskObserver( MCABackGroundTaskObserver *aObserver )

    {

    iEngine.UnRegisterBackGroundTaskObserver( aObserver );

    }

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

// CCALoginPC::IsBackgroundTaskPending

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

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

//

TBool CCALoginPC::IsBackgroundTaskPending()

    {

    return iEngine.IsBackgroundTaskPending();

    }

//    End of File