/*

* Copyright (c) 2002-2010 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:  Presence handler.

*

*/

#include <ximperrors.hrh>

#include <ximpcontext.h>

#include <presenceinfo.h> //MximpPresenceInfo

#include <presenceinfofilter.h> //info filtter

#include <presenceinfofield.h> //MximpPresenceInfoField

#include <ximpobjectfactory.h>

#include <presenceobjectfactory.h>

#include <servicepresenceinfo.h> //MximpServicePresenceInfo

#include <presenceinfofieldvalueenum.h> //MximpPresenceInfoFieldValueEnum

#include <presenceinfofieldcollection.h> //MximpPresenceInfoFieldCollection

#include <presenceinfofieldvaluetext.h> //MximpPresenceInfoFieldValueText

#include <personpresenceinfo.h> // MximpPersonPresenceInfo

#include <presencepublishing.h>//MPresencePublishing

#include <ximpfeatureinfo.h>

#include <presencefeatures.h>

#include <ximpidentity.h> //for MXIMPIdentity

#include <presentitygroups.h>

#include <ximprequestcompleteevent.h>

#include <ximpcontextstateevent.h>

#include <ownpresenceevent.h>

#include <ximpclient.h>

#include <ximpcontext.h>

#include <ximpstatus.h>

#include <pressettingsapi.h> //presence settings

#include <XdmSettingsApi.h>

#include <cvimpstsettingsstore.h>

#include "scppresencehandler.h"

#include "scpsubservice.h"

#include "scpservicestorage.h"

#include "scplogger.h"

#include "scputility.h"

#include "scpservice.h"

#include "scpprofilehandler.h"

#include "scpsettinghandler.h"

#include "scppresencehandlerrequest.h"

const TInt KXdmDmMaxIntLength      = 10;   // max length of 32bit integer

const TInt KMaxPresenceEnableCount = 5;

const TInt KCustomMessageMaxLength = 75;

const TInt KBufSize255 = 255;

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

// CScpPresenceHandler::NewL

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

//

CScpPresenceHandler* CScpPresenceHandler::NewL( CScpSubService& aSubService )

    {

    SCPLOGSTRING( "CScpPresenceHandler::NewL" );

    CScpPresenceHandler* self = new ( ELeave ) CScpPresenceHandler( aSubService );

    CleanupStack::PushL( self );    

    self->ConstructL();    

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpPresenceHandler::CCScpPresenceHandler

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

//

CScpPresenceHandler::CScpPresenceHandler( CScpSubService& aSubService ) :

    CScpServiceHandlerBase( aSubService ),

    iPresenceState( ENoBind ),

    iDisableAfterXimpRequestsCompleted( EFalse ),

    iNetworkLostRoamingOngoing( EFalse )

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::CScpPresenceHandler", this );

    }

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

// CScpPresenceHandler::ConstructL

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

//

void CScpPresenceHandler::ConstructL()

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::ConstructL", this );

    BaseConstructL();

    GetPresencePropertyIdL( ESubPropertyPresenceSettingsId, iPresenceSettingsId );

    iPresClient = MXIMPClient::NewClientL();

    SCPLOGSTRING2( "CScpPresenceHandler::ConstructL, iPresClient [0x%x]", iPresClient );

    if ( iPresClient )

        {

        // Set presence handler as observer of Voip subservice

        CScpSubService* voipSubService = GetVoipSubService();

        if ( voipSubService )

            {

            voipSubService->SetSubServiceObserver( this );

            }

        MXIMPContext* tmp = iPresClient->NewPresenceContextLC();        

        iFeature = MPresenceFeatures::NewL( tmp );

        RArray<TInt32> eventFilter;   

        CleanupClosePushL( eventFilter );

        eventFilter.Append( XIMP_IF_ID_REQUEST_COMPLETE_EVENT );     

        eventFilter.Append( XIMP_IF_ID_CONTEXT_STATE_EVENT );

        TArray<TInt32> eventFilterArray = eventFilter.Array();

        tmp->RegisterObserverL( *this, &eventFilterArray );

        CleanupStack::PopAndDestroy( &eventFilter );

        CleanupStack::Pop(); // tmp

        iPresenceCtx = tmp;

        tmp = NULL; 

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    }

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

// CScpPresenceHandler::~CScpPresenceHandler

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

//

CScpPresenceHandler::~CScpPresenceHandler()

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::~CScpPresenceHandler", this );

    CancelDisableTimer();

    iReqIdArray.Close();

    delete iFeature;

    delete iPresenceCtx;

    // Set observer of Voip subservice to NULL

    CScpSubService* voipSubService = GetVoipSubService();

    if ( voipSubService )

        {

        voipSubService->SetSubServiceObserver( NULL );

        }

    delete iPresClient;

    }

// ====================== From CScpServiceHandlerBase ==========================

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

// CScpPresenceHandler::EnableSubServiceL

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

//

void CScpPresenceHandler::EnableSubServiceL()

    {

    SCPLOGSTRING4( "CScpPresenceHandler[0x%x]::EnableSubServiceL: 0x%x type: %i", 

                   this, &iSubService, iSubService.SubServiceType() );

    __ASSERT_DEBUG( iSubService.SubServiceType() == ECCHPresenceSub,

                    User::Panic( KNullDesC, KErrGeneral ) );     

    CScpServiceHandlerBase::RegisterProfileL();

    }

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

// CScpPresenceHandler::DisableSubService

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

//

TInt CScpPresenceHandler::DisableSubService()

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::DisableSubService", this );

    __ASSERT_DEBUG( iSubService.SubServiceType() == ECCHPresenceSub,

                    User::Panic( KNullDesC, KErrGeneral ) );  

    TInt result = KErrNone;

    // Publish offline and unbind presence context

    TRAP( result, HandleDeregistrationL( ETrue ) );

    if ( KErrNone == result  )

        {

        // Deregister if still connecting

        if ( iSubService.State() == ECCHConnecting )

            {

            DeregisterNow();            

            }

        else

            {

            StartForcedDisableTimer( CScpPresenceHandler::ForcePresenceServiceDisable );

            }

        }

    else

        {

        // Wait for XIMP request to be completed and handle 

        // de-registration after that or after force disable timer expires

        if ( iReqIdArray.Count() )

            {

            iDisableAfterXimpRequestsCompleted = ETrue;

            StartForcedDisableTimer( CScpPresenceHandler::ForcePresenceServiceDisable );

            }

        else

            {

            DeregisterNow();

            }

        }

    return result;

    }

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

// CScpPresenceHandler::SubServiceType

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

//

TCCHSubserviceType CScpPresenceHandler::SubServiceType() const

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::SubServiceType", this );

    return ECCHPresenceSub;

    }

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

// CScpPresenceHandler::HandleSipConnectionEvent

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

//

void CScpPresenceHandler::HandleSipConnectionEvent( const TUint32 aProfileId,

                                                    TScpConnectionEvent aEvent )

    {

    SCPLOGSTRING4( "CScpPresenceHandler[0x%x]::HandleSipConnectionEvent id: %d event: %d",

                   this, aProfileId, aEvent );

    iNetworkLostRoamingOngoing = EFalse;

    if ( iSubService.SipProfileId() == aProfileId &&

        iSubService.EnableRequestedState() != CScpSubService::EScpNoRequest )

        {

        //if network lost, unbind context

        if ( EScpNetworkLost == aEvent )

            {

            SCPLOGSTRING( "CScpPresenceHandler - EScpNetworkLost -> unbind" );

            TRAPD( err, HandleDeregistrationL( EFalse ) );

            if ( KErrNotReady == err )

                {

                SCPLOGSTRING( "CScpPresenceHandler - EScpNetworkLost -> not ready: unbind" );

                TRAP_IGNORE( ServerUnBindL() );

                }

            TUint32 snapId;

            CScpProfileHandler& profileHandler = iSubService.ProfileHandler();

            CScpSipConnection* sipConnection = profileHandler.GetSipConnection( iSubService.SipProfileId() );

            if ( sipConnection )

                {

                TInt error = sipConnection->GetSnap( snapId );

                if ( !error && sipConnection->IsSnapConnectionAvailable( snapId ) )

                    {

                    iNetworkLostRoamingOngoing = ETrue;

                    }

                }

            }

        if ( EScpRoaming == aEvent )

            {

            SCPLOGSTRING( "CScpPresenceHandler - EScpRoaming -> unbind" );

            TRAP_IGNORE( ServerUnBindL() );

            }

        //if registered, time to bind context

        if ( EScpRegistered == aEvent &&

             CScpSubService::EScpEnabled == iSubService.EnableRequestedState() )

            {

            SCPLOGSTRING( "CScpPresenceHandler - EScpRegistered -> update iap and bind" );

            // update xmd settings 

            TRAPD( err, UpdateXdmSettingsL() );

            if ( KErrNone == err )

                {

                // Subscribe

                TRAP( err, ServerBindL() );

                iRebind = EFalse;

                if( KErrNone == err )

                    {

                    // Still connecting the service

                    aEvent = EScpNetworkFound;    

                    }

                else

                    {

                    SCPLOGSTRING2( "ServerBindL failed: %d", err );

                    aEvent = EScpRegistrationPending;

                    if ( KErrAlreadyExists == err )

                        {

                        // Ximp does not set request to queue, so we have to do rebind later

                        SCPLOGSTRING( "CScpPresenceHandler - rebind later" ); 

                        iRebind = ETrue;

                        }

                    }

                }

            else

                {

                SCPLOGSTRING2( "UpdateXdmSettingsL: %d", err );

                aEvent = EScpRegistrationFailed;

                }

            }

        else if ( EScpDeregistered == aEvent &&

                 iSubService.EnableRequestedState() == CScpSubService::EScpDisabled ||

                 iSubService.EnableRequestedState() == CScpSubService::EScpRefreshed )

            {

            if ( EScpRegistered != aEvent && ECCHDisconnecting != iSubService.State() )

                {

                CancelDisableTimer();

                }

            // If this flag is still true, it could be that presence server

            // has not given answer -> ximp requests cannot be completed.

            // But still have to unbind from ximp context

            if ( iDisableAfterXimpRequestsCompleted )

                {

                TRAP_IGNORE( ServerUnBindL() );

                }

            // When SIP is deregistered, change presence state to no bind

            iPresenceState = ENoBind;

            }

        iSubService.HandleConnectionEvent( aEvent );

        }

    SCPLOGSTRING( "CScpPresenceHandler::HandleSipConnectionEvent OUT" );

    }    

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

// CScpPresenceHandler::HandleSipConnectionEvent

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

//

TBool CScpPresenceHandler::IsSipProfileAllowedToStartAlr()

    {

    return EFalse;

    }

// ======================= From MXIMPContextObserver ===========================

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

// CScpPresenceHandler::HandlePresenceContextEvent

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

//   

void CScpPresenceHandler::HandlePresenceContextEvent(

    const MXIMPContext& /*aContext*/,

    const MXIMPBase& aEvent )

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::HandlePresenceContextEvent", this );

    const TInt32 eventType = aEvent.GetInterfaceId();

    switch ( eventType )

        {

        case MXIMPContextStateEvent::KInterfaceId:

            {

            HandleContextStateEvent( aEvent );

            break;

            }

        case MXIMPRequestCompleteEvent::KInterfaceId:

            {

            HandleRequestCompleteEvent( aEvent );

            break;

            }

        default:

            {

            break;

            }

        }

    SCPLOGSTRING( "CScpPresenceHandler::HandlePresenceContextEvent end" ); 

    }

// ===================== From MScpSubServiceObserver ===========================

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

// CScpPresenceHandler::HandleSubServiceChange

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

//

void CScpPresenceHandler::HandleSubServiceChange( TCCHSubserviceState aState, TInt aError )

    {

    SCPLOGSTRING4( "CScpPresenceHandler::HandleSubServiceChange presence subservice state: %d, aState: %d, aError: %d", 

                    iSubService.State(), aState, aError );

    if ( iSubService.State() == ECCHEnabled && ( aError == KCCHErrorBandwidthInsufficient || aError == KErrNone ) )

        {

        if( aState == ECCHEnabled && aError == KErrNone )

            {

            if ( EPresenceOffline == iPresenceState )

                {

                SCPLOGSTRING( "CScpPresenceHandler::HandleSubServiceChange PublishOnline" );

                TRAP_IGNORE( PublishPresenceL( ETrue ) );

                }

            }

        else

            {

            if ( EPresenceOnline == iPresenceState && aState != ECCHConnecting )

                {

                SCPLOGSTRING( "CScpPresenceHandler::HandleSubServiceChange PublishOffline" );

                // Unsubscribe from the list first

                TRAP_IGNORE( UnsubscribePresentityGroupL() );

                TRAP_IGNORE( PublishPresenceL( EFalse ) );

                }

            }

        }

    }

// ========================= Other member funcions =============================

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

// CScpPresenceHandler::GetVoipSubService

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

//

CScpSubService* CScpPresenceHandler::GetVoipSubService()

    {

    CScpSubService* voipSubService = NULL;

    CScpServiceStorage& serviceStorage = iSubService.ServiceStorage();

    CScpService* service = serviceStorage.GetServiceByServiceId( iSubService.SubServiceId() );

    if ( service )

        {

        voipSubService = service->GetSubServiceByType( ECCHVoIPSub );

        }

    return voipSubService;

    }

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

// CScpPresenceHandler::DeregisterNow

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

//

void CScpPresenceHandler::DeregisterNow()

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::DeregisterNow",

                   this );

    CancelDisableTimer();

    iReqIdArray.Reset();

    iPresenceState = ENoBind;

    // Check if disable was not requested

    if ( iSubService.EnableRequestedState() == CScpSubService::EScpEnabled )

        {

        // Check the last ximp error

        if ( KErrNoMemory == iLastXimpError && 

            KMaxPresenceEnableCount < iSubService.EnableCounter() )

            {

            // No memory means 401 Unauthorized, we are trying to enable  

            // KMaxPresenceEnableCount times -> no more, this is truly

            // autentication failed.

            iSubService.HandleConnectionEvent( EScpAuthenticationFailed );

            }

        else

            {

            iSubService.HandleConnectionEvent( EScpDeregistered );

            }

        }

    else

        {

        DeregisterProfile();

        }

    }

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

// CScpPresenceHandler::ForcePresenceServiceDisable

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

//

TInt CScpPresenceHandler::ForcePresenceServiceDisable( TAny* aSelf )

    {

    SCPLOGSTRING( "CScpPresenceHandler::ForcePresenceServiceDisable" );

    CScpPresenceHandler* self = static_cast<CScpPresenceHandler*>( aSelf );

    self->DeregisterNow();

    return 1;

    }

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

// CScpPresenceHandler::UpdateXdmSettingsL

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

//

void CScpPresenceHandler::UpdateXdmSettingsL()

    {

    SCPLOGSTRING2( "CScpPresenceHandler[0x%x]::UpdateXdmSettingsL", this );

    // Get IAP id of sip profile

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();

    CScpSipConnection* sipConnection = profileHandler.GetSipConnection( iSubService.SipProfileId() );

    if ( !sipConnection )

        {

        User::Leave( KErrNotFound );

        }

    TUint32 apId = 0;