/*

* Copyright (c) 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: Implementation for CVIMPSTEngineSessionCntxtObserver

*

*/

#include "cvimpstenginesessioncntxtobserver.h"

#include "tvimpstenums.h"

#include "cvimpstenginerequestmapper.h"

#include "cvimpstenginerequest.h"

#include "mvimpstenginesearchextentioneventobserver.h"

#include "mvimpstenginesessioncntxtobserver.h"

//ximpfw

#include <presencegrantrequestinfo.h>

#include <presentitygroupcontentevent.h>

#include <ximpcontext.h>

#include <presenceinfofilter.h>

#include <presencefeatures.h>

#include <presenceobjectfactory.h>

#include <presenceinfo.h>

#include <presenceauthorization.h>

#include <ximpidentity.h>

#include <ximpobjectfactory.h>

#include <searchinfo.h>

#include <searchevent.h>

#include <ximpclient.h>

#include <ximpidentity.h>

#include <ximpstatus.h>

#include <ximpcontextstateevent.h>

#include <ximprequestcompleteevent.h>

#include <presentitypresenceevent.h>

#include <presenceblocklistevent.h>

#include <presencegrantrequestlistevent.h>

#include <ximpcontextstate.h>

#include <searchelement.h>

#include <searchkeysevent.h>

#include <searchkeyinfo.h>

#include <ximpfeatureinfo.h>

//xmppsettings

#include "xmppparams.h"

#include "xmppservicesettingsapi.h"

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

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

// CVIMPSTEngineSessionCntxtObserver::NewL

// two phase construction

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

CVIMPSTEngineSessionCntxtObserver* CVIMPSTEngineSessionCntxtObserver::NewL( TUint32 aServiceId )

    {

    CVIMPSTEngineSessionCntxtObserver* self = 

    					CVIMPSTEngineSessionCntxtObserver::NewLC( aServiceId);

    CleanupStack::Pop( self );

    return self;

    }

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

// CVIMPSTEngineSessionCntxtObserver::NewLC

// two phase construction

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

CVIMPSTEngineSessionCntxtObserver* CVIMPSTEngineSessionCntxtObserver::NewLC(TUint32 aServiceId)

    {

    CVIMPSTEngineSessionCntxtObserver* self = new 

    					(ELeave) CVIMPSTEngineSessionCntxtObserver( aServiceId);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVIMPSTEngineSessionCntxtObserver::ConstructL

// two phase construction

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

void CVIMPSTEngineSessionCntxtObserver::ConstructL()

	{

	iRequestMapper = CVIMPSTEngineRequestMapper::NewL();	

	iReqResult = KErrNone;

	iClient = MXIMPClient::NewClientL();               

    //Create new sink to receive ximp context events

	iPresenceCtx = iClient->NewPresenceContextLC();

    // ignore code scanner warning, it gives panic

    CleanupStack::Pop();// because of LC method    

	iFeatures = MPresenceFeatures::NewL(iPresenceCtx);

	//Stores the XIMPFw EventTypes Subscribed for      

	iAcceptedEventTypes.Reset();

    iAcceptedEventTypes.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );

    iAcceptedEventTypes.AppendL( MXIMPContextStateEvent::KInterfaceId );

    iAcceptedEventTypes.AppendL( MPresentityGroupContentEvent::KInterfaceId );   

    iAcceptedEventTypes.AppendL( MPresenceGrantRequestListEvent::KInterfaceId );

	iAcceptedEventTypes.AppendL( MSearchEvent::KInterfaceId );   

    iAcceptedEventTypes.AppendL( MSearchKeysEvent::KInterfaceId );

    iAcceptedEventTypes.AppendL( MPresenceBlockListEvent::KInterfaceId );

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

	// register this to prsence context   

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

	}

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

// CVIMPSTEngineSessionCntxtObserver::~CVIMPSTEngineSessionCntxtObserver

// destructor

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

CVIMPSTEngineSessionCntxtObserver::~CVIMPSTEngineSessionCntxtObserver()

    {

    iObserverArray.Reset();

    iObserverArray.Close();

    iAcceptedEventTypes.Reset();

    iAcceptedEventTypes.Close();

    delete iFeatures;

    if(iPresenceCtx)

        {

        iPresenceCtx->UnregisterObserver( *this );

        delete  iPresenceCtx;   

        }

    delete iClient;           

    delete iRequestMapper;

    }

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

// CVIMPSTEngineSessionCntxtObserver::CVIMPSTEngineSessionCntxtObserver

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

CVIMPSTEngineSessionCntxtObserver::CVIMPSTEngineSessionCntxtObserver(TUint32 aServiceId)

:iServiceId(aServiceId),

 iBindStatus( TVIMPSTEnums::EVIMPSTBindNotDone )

    {

    }

// ===========================================================================

// FROM MPRFWximpCONTEXTOBSERVER

// ===========================================================================

//

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

// CVIMPSTEngineSessionCntxtObserver::HandlePresenceContextEvent

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

void CVIMPSTEngineSessionCntxtObserver::HandlePresenceContextEvent( 

    const MXIMPContext& aContext,

    const MXIMPBase& aEvent )

    {

    TRAP_IGNORE(DoHandlePresenceContextEventL( aContext, aEvent ));

    }    

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

// CVIMPSTEngineSessionCntxtObserver::GetCompletedReqResult

// 

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

TInt CVIMPSTEngineSessionCntxtObserver::GetCompletedReqResult() const

	{

	return iReqResult;	

	}

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

// CVIMPSTEngineSessionCntxtObserver::CVIMPSTEngineSessionCntxtObserver

// 

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

CVIMPSTEngineRequestMapper* CVIMPSTEngineSessionCntxtObserver::

											GetRequestMapper() const

	{

	return iRequestMapper;	

	}

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

// CVIMPSTEngineSessionCntxtObserver::ContextBindStatus

// 

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

TVIMPSTEnums::TVIMPSTBindStatus CVIMPSTEngineSessionCntxtObserver::ContextBindStatus()

	{

	return iBindStatus;	

	}

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

// CVIMPSTEngineSessionCntxtObserver::ServerBindL

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

//

TInt CVIMPSTEngineSessionCntxtObserver::ServerBindL(TUid aProtocolUid)

    {

    TInt err = KErrNotFound;

    //Bind context to desired presence service

    if ( TVIMPSTEnums::EVIMPSTBindDone != iBindStatus )

        {  

        TXIMPRequestId operationId = TXIMPRequestId::Null();

        TRAP( err, operationId = iPresenceCtx->BindToL( 

                aProtocolUid, iServiceId ) );

        if ( err )

            {

            // XIMP queues all operations except bind operation. If there is

            // unbind operation pending in ximp side, bind call will leave

            // with KErrAlreadyExists. Client side is not ideal place to 

            // handle this type of logic so to work around this problem, this 

            // case is flagged here. When unbind completes, rebind is done. 

            // If unbind is called between these operations, flag is set 

            // ESVCEPresenceBindNotDone to avoid bind if service was disabled

            iBindStatus = TVIMPSTEnums::EVIMPSTBindFailureMode;

            }

        else

            {

            //create the requestmapper for the corresponidng reuqest id.

            iRequestMapper->CreateRequestL(operationId,ETrue,EVIMPSTXimpOperationBind);

            iBindStatus = TVIMPSTEnums::EVIMPSTBindDone; 

            iFeatureSupported = EVIMPSTFeatureUnknown;

            TRAP(err,IdentifySupportedFeaturesL());

            }

        }

    else

        {

        err = KErrNone;

        }

    return err;

    }

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

// CVIMPSTEngineVoIPPrecenseHandler::ServerUnBindL

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

//

TInt CVIMPSTEngineSessionCntxtObserver::ServerUnBindL( 

    TBool aDoUnsubscribe )

    {

	TInt err = KErrNotFound;

	if ( TVIMPSTEnums::EVIMPSTBindDone == iBindStatus )

		{

		if ( aDoUnsubscribe )

			{

			iBindStatus = TVIMPSTEnums::EVIMPSTUnBinding;

			}

		TXIMPRequestId operationId = TXIMPRequestId::Null(); 

		TRAP( err, operationId = iPresenceCtx->UnbindL());

		iBindStatus = TVIMPSTEnums::EVIMPSTUnBindWaiting;

		iRequestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationUnBind) ;

		iBindStatus = TVIMPSTEnums::EVIMPSTBindNotDone;

		iFeatureSupported = EVIMPSTFeatureUnknown;

		}

	else if ( TVIMPSTEnums::EVIMPSTBindFailureMode == iBindStatus )

		{

		// Disable flag here. If service is really disabled, we must not

		// rebind when unbind completes.

		iBindStatus = TVIMPSTEnums::EVIMPSTBindNotDone;

		}

	return err;

    } 

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

// CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC

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

//

HBufC* CVIMPSTEngineSessionCntxtObserver::UriFromXimpOperationLC(const MXIMPBase& aEvent )

    {

    const MPresentityPresenceEvent& event =

            *TXIMPGetInterface< const MPresentityPresenceEvent >::From( 

                aEvent, MXIMPBase::EPanicIfUnknown );  

    HBufC* retValue = NULL;

    retValue = event.PresentityId().Identity().AllocLC();

    if(!retValue)

        {

        retValue = KNullDesC().AllocLC();

        }

    return retValue;    

    }

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

// CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL

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

//

void CVIMPSTEngineSessionCntxtObserver::DoHandlePresenceContextEventL(

    const MXIMPContext& aContext,

    const MXIMPBase& aEvent )

    {

    const TInt32 eventId = aEvent.GetInterfaceId();

        switch( aEvent.GetInterfaceId() )

            {

            case MXIMPRequestCompleteEvent::KInterfaceId:

                {

                const MXIMPRequestCompleteEvent* event =

                    TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From( 

                        aEvent, MXIMPBase::EPanicIfUnknown );

                iReqResult = event->CompletionResult().ResultCode();

                const TXIMPRequestId& reqId = event->RequestId();

                // Note:FindRequestId does not pass the ownership. hanece req

                // should not be deleted.

                CVIMPSTEngineRequest *req = iRequestMapper->FindRequestId( reqId );                

                if ( req )

                    {                                        

                    TXimpOperation operation = req->RequestType(); 

                    //contact mgmt & search will remove their own requests

                    //presence subservice should also do the same 

                    //untill then use the below if check 

                    //TBD

                    if ( (operation>EVIMPSTXimpOperationNoOperation)&&

                    		(operation<=EVIMPSTXimpOperationUnsubscribe) )

	                    {

	                    req->StopWait() ;   

	                    iRequestMapper->RemoveRequestId(reqId);              

	                    }

                    TInt count = iObserverArray.Count();

                    for(TInt i = 0; i < count; i++)

	                    {

	                    iObserverArray[i]->HandleSessionContextEventL(aContext,

	                    						aEvent,

	                    						operation);

	                    }

                    }

                break;

                }

            case MXIMPContextStateEvent::KInterfaceId:

                {

                break;

                }

            case MPresentityPresenceEvent::KInterfaceId:

                {

                TInt count = iObserverArray.Count();

                for(TInt i = 0; i < count; i++)

                    {

                    iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                    }

                break;

                }

            case MPresentityGroupContentEvent::KInterfaceId:

               {

               TInt count = iObserverArray.Count();

               for(TInt i = 0; i < count; i++)

                  {

                  iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                  }

               break;  

               }

            case MPresenceGrantRequestListEvent::KInterfaceId:

               {

               TInt count = iObserverArray.Count();

               for(TInt i = 0; i < count; i++)

                  {

                  iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                  }               

               break;

               }

            case MSearchEvent::KInterfaceId:

                {

                TInt count = iObserverArray.Count();

                for(TInt i = 0; i < count; i++)

                   {

                   iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                   } 

                break;

                }

            case MSearchKeysEvent::KInterfaceId:

                {

                TInt count = iObserverArray.Count();

                for(TInt i = 0; i < count; i++)

                   {

                   iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                   } 

                break;

                }

            case MPresenceBlockListEvent::KInterfaceId:

               {

               TInt count = iObserverArray.Count();

               for(TInt i = 0; i < count; i++)

                  {

                  iObserverArray[i]->HandleSessionContextEventL(aContext,aEvent);

                  } 

               break;

               }

            default:

                {

                break;

                }

            }

    }

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

// CVIMPSTEngineSessionCntxtObserver::XimpAuthorizationL

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

// 

MPresenceAuthorization& 

CVIMPSTEngineSessionCntxtObserver::XimpAuthorizationL()

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotSupported ));

    __ASSERT_ALWAYS( &iFeatures->PresenceAuthorization(), 

        User::Leave( KErrNotSupported ));

    return iFeatures->PresenceAuthorization();

    }

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

// CVIMPSTEngineSessionCntxtObserver::XimpPresenceWatchingL

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

//

MPresenceWatching& 

CVIMPSTEngineSessionCntxtObserver::XimpPresenceWatchingL()

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotSupported ));

    __ASSERT_ALWAYS( &iFeatures->PresenceWatching(), 

        User::Leave( KErrNotSupported ));

    return iFeatures->PresenceWatching();

    }    

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

// CVIMPSTEngineSessionCntxtObserver::XimpPresentityGroupsL

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

//

MPresentityGroups& 

CVIMPSTEngineSessionCntxtObserver::XimpPresentityGroupsL()

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotSupported ));

    __ASSERT_ALWAYS( &iFeatures->PresentityGroups(), 

        User::Leave( KErrNotSupported ));

    return iFeatures->PresentityGroups();

    }        

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

// CVIMPSTEngineSessionCntxtObserver::XimpPresencePublishingL

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

//

MPresencePublishing& 

CVIMPSTEngineSessionCntxtObserver::XimpPresencePublishingL()

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotSupported ));

    __ASSERT_ALWAYS( &iFeatures->PresencePublishing(), 

        User::Leave( KErrNotSupported ));

    return iFeatures->PresencePublishing();

    }

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

// CVIMPSTEngineSessionCntxtObserver::XimpPresenceContext

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

//

MXIMPContext& 

CVIMPSTEngineSessionCntxtObserver::XimpPresenceContextL()

    {

    __ASSERT_ALWAYS( iPresenceCtx, User::Leave( KErrNotFound ));

     return *iPresenceCtx;

    }

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

// CVIMPSTEngineSessionCntxtObserver::PresenceObjectFactory

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

//

MPresenceObjectFactory& CVIMPSTEngineSessionCntxtObserver::PresenceObjectFactoryL() const

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotFound ));

    return iFeatures->PresenceObjectFactory();

    }

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

// CVIMPSTEngineSessionCntxtObserver::PresenceFeaturesL

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

//

MPresenceFeatures& CVIMPSTEngineSessionCntxtObserver::PresenceFeaturesL() const

    {

    __ASSERT_ALWAYS( iFeatures, User::Leave( KErrNotFound ));

    return *iFeatures;

    }

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

// CVIMPSTEngineSessionCntxtObserver::RegisterObserver

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

//

void CVIMPSTEngineSessionCntxtObserver::RegisterObserver(MVIMPSTEngineSessionCntxtObserver* aObserver)

    {