/*

* Copyright (c) 2007-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:  single context observer implementation

*

*/

#include "cimcvenginecontextobserver.h"

#include <ximpidentity.h>

#include <ximpstatus.h>

#include <ximpcontextstateevent.h>

#include <ximprequestcompleteevent.h>

#include <presentitypresenceevent.h>

#include <presentitygrouplistevent.h>

#include <presentitygroupinfo.h>

#include <presentitygroupcontentevent.h>

#include <presentitygroupmemberinfo.h>

#include <ximpcontextstate.h>

#include "imcvuiliterals.h"

#include "mimcvenginenewmessagehandler.h"

#include "imcvlogger.h"

#include <imerrors.hrh>

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

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

// CIMCVEngineContextObserver::NewL

// two phase construction

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

CIMCVEngineContextObserver* CIMCVEngineContextObserver::NewL()

    {

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::NewL() start") );

    CIMCVEngineContextObserver* self = 

    					CIMCVEngineContextObserver::NewLC();

    CleanupStack::Pop( self );

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::NewL() end") );

    return self;

    }

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

// CIMCVEngineContextObserver::NewLC

// two phase construction

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

CIMCVEngineContextObserver* CIMCVEngineContextObserver::NewLC()

    {

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::NewLC() start") );

    CIMCVEngineContextObserver* self = new 

    					(ELeave) CIMCVEngineContextObserver();

    CleanupStack::PushL( self );

    self->ConstructL();

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::NewLC() end") );

    return self;

    }

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

// CIMCVEngineContextObserver::ConstructL

// two phase construction

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

void CIMCVEngineContextObserver::ConstructL()

	{

	}

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

// CIMCVEngineContextObserver::~CIMCVEngineContextObserver

// destructor

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

CIMCVEngineContextObserver::~CIMCVEngineContextObserver()

    {

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::~CIMCVEngineContextObserver() start") );

     if(iWait.IsStarted() )

	    {

	    iWait.AsyncStop();	

	    }

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::~CIMCVEngineContextObserver() end") );

    }

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

// CIMCVEngineContextObserver::CIMCVEngineContextObserver

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

CIMCVEngineContextObserver::CIMCVEngineContextObserver() :

iCurrentReqType(EReqUnknown)

    {

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::CIMCVEngineContextObserver() start") );

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::CIMCVEngineContextObserver() end") );

    }

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

// FROM MPRFWximpCONTEXTOBSERVER

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

//

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

// CIMCVEngineContextObserver::HandleximpContextEvent

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

void CIMCVEngineContextObserver::HandlePresenceContextEvent( 

    const MXIMPContext& /*aContext*/,

    const MXIMPBase& aEvent )

    {

  	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::HandlePresenceContextEvent() start") );

    const TInt32 eventType = aEvent.GetInterfaceId();

    switch( eventType )

        {

        case MXIMPRequestCompleteEvent::KInterfaceId:

			{

            const MXIMPRequestCompleteEvent* event =

                TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From( aEvent, MXIMPBase::EPanicIfUnknown );

            TXIMPRequestId reqId = event->RequestId();

            const MXIMPStatus& status = event->CompletionResult();

            TInt err = status.ResultCode();

            //Login request has been issued            

            if ((iCurrentXIMPReq == reqId) && (ELoginReq == iCurrentReqType))

	            {

				//Login is an synchronous call	            

	            if ( iWait.IsStarted() )

					{

					iWait.AsyncStop();	

					}

				if(KErrNone == err )

	                {	                

	                iLoggedIn = ETrue;	                		                

	                }

                else

	                {	                

	                iLoggedIn = EFalse;	                

	                } 	            

				iCurrentReqType = EReqUnknown;	

				if(iSessionObserver)

					{

					TRAP_IGNORE( iSessionObserver->HandleConnectionEventL( ELoggedIn, KErrNone ) );  				

					}				                	

	            }

	        //Logout request has been issued    

			else if ((iCurrentXIMPReq == reqId) && (ELogoutReq == iCurrentReqType))  

				{

				//Login is an synchronous call	            

	            if ( iWait.IsStarted() )

					{

					iWait.AsyncStop();	

					}

				iLoggedIn = EFalse;	

				iCurrentReqType = EReqUnknown;	

				if(iSessionObserver)

					{

					TRAP_IGNORE( iSessionObserver->HandleConnectionEventL(ELoggedOut, KErrNone ) );  				

					}			

				}

			//SendMessage request has been issued	

			else

				{

				// for message delivery report

			    if( iSessionObserver && iLoggedIn )

				    {

				    TRAP_IGNORE( iSessionObserver->HandleDeliveryReportL(reqId, status.ResultCode() ) );	

				    }	

				}

            break;

            }

        case MXIMPContextStateEvent::KInterfaceId:

        	{        	

        	// what do we do with context state event

        	// state of the context can be associated with the 

        	const MXIMPContextStateEvent* ctxtStateEvent = 

            TXIMPGetInterface< const MXIMPContextStateEvent >::From( aEvent, 

                                                                     MXIMPBase::EPanicIfUnknown );

            const MXIMPStatus* fwStatus = ctxtStateEvent->StateChangeReason();

            const MXIMPContextState& cState = ctxtStateEvent->ContextState();

            MXIMPContextState::TState state = cState.ContextState();          

            if (MXIMPContextState::EInactive == state  )

				{

				//No request of Login/Logout has been issued by CV

				//Hence this might be a server initiated disconnect

				//handle properly

			 	if( (iSessionObserver) && (EReqUnknown == iCurrentReqType) )

					{

					TRAP_IGNORE( iSessionObserver->HandleConnectionEventL(EForcedLoggedOut, KImErrServiceForceClosedSession ) );  

					}

				}

             break;

        	}

       default:

        	{

        	break;

			}

        }

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::HandlePresenceContextEvent() end") );

    }

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

// CIMCVEngineContextObserver::GetCompletedReqResult

// 

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

void CIMCVEngineContextObserver::GetConnectedSessionL(MXIMPContext& aContext, TInt aServiceId, TUid aProtocolUid)

	{

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::GetConnectedSessionL() start") );

	//TUid protocolUid = TUid::Uid( KProtocolUidTelepathy );

	if ( (!iLoggedIn) && (EReqUnknown == iCurrentReqType) )

	    {

	    //iOngoingOperation = TIMCVStateEnums::EIMCVLogging;

	    iCurrentXIMPReq = aContext.BindToL( aProtocolUid, aServiceId ) ;

	    iCurrentReqType = ELoginReq;

	    if( !iWait.IsStarted() )

	        {

	        // Code scanner warning "active object called without checking 

	        // whether it is active or cancelling it first" ignored because

	        // CActiveSchedulerWait is not an active object

	        iWait.Start(); // CSI: 10 # See above

	        }

	    //iOngoingOperation = TIMCVStateEnums::EIMCVUnknown;

	    }

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::GetConnectedSessionL() end") );

	}

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

// CIMCVEngineContextObserver::GetCompletedReqResult

// 

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

void CIMCVEngineContextObserver::ReleaseConnectionL(MXIMPContext& aContext)

	{

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::ReleaseConnectionL() start") );

	if ( (iLoggedIn) && (EReqUnknown == iCurrentReqType) )

	    {

	    //iOngoingOperation = TIMCVStateEnums::EIMCVLoggingOut;

	    iCurrentXIMPReq = aContext.UnbindL() ;

	    iCurrentReqType = ELogoutReq;

	    if( !iWait.IsStarted() )

	        {

	        // Code scanner warning "active object called without checking 

	        // whether it is active or cancelling it first" ignored because

	        // CActiveSchedulerWait is not an active object

	        iWait.Start(); // CSI: 10 # See above	

	        }

	    }

    IM_CV_LOGS(TXT("CIMCVEngineContextObserver::ReleaseConnectionL() end") );

	}

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

// CIMCVEngineContextObserver::IsLoggedIn

// 

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

TBool CIMCVEngineContextObserver::IsLoggedIn() const

	{

	return 	iLoggedIn;

	}

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

// CIMCVEngineContextObserver::RegisterObserver

// 

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

void CIMCVEngineContextObserver::RegisterObserver(MIMCVEngineServiceSessionHandler* aObserver)  

	{

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::RegisterObserver() start") );

	iSessionObserver = 	aObserver;

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::RegisterObserver() end") );

	}

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

// CIMCVEngineContextObserver::UnRegisterObserver

// 

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

void CIMCVEngineContextObserver::UnRegisterObserver(MIMCVEngineServiceSessionHandler* /*aObserver*/)  

	{

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::UnRegisterObserver() start") );

	// do not call delete 

	// not owned by this class

	iSessionObserver = NULL;

	IM_CV_LOGS(TXT("CIMCVEngineContextObserver::UnRegisterObserver() end") );

	}

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

// CIMCVEngine::SetLoggedIn()

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

//

void CIMCVEngineContextObserver::SetLoggedIn(TBool aState) 

	{

	iLoggedIn = aState;

	}	

// end of file