/*

* Copyright (c) 2005 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:   Server session class.

*

*/

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

// INCLUDE FILES

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

//

#include "CNcnSession.h"

#include "NcnCommsDefs.h"

#include "CNcnUnpackDescrArray.h"

#include "MNcnNotificationObserver.h"

#include <MNcnNotification.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

}  // namespace

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

// CNcnSession::CNcnSession

//

// Constructor.

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

//

CNcnSession::CNcnSession( MNcnNotificationObserver& aObserver )

    : iObserver( aObserver )

    {

    }

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

// CNcnSession::ConstructL

//

// Symbian 2nd phase constructor.

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

//    

void CNcnSession::ConstructL()

    {

    }

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

// CNcnSession::~CNcnSession

//

// Destructor.

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

//        

CNcnSession::~CNcnSession()

    {

    }

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

// CNcnSession::NewL

//

// Symbian two-phased construction.

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

//

CNcnSession* CNcnSession::NewL( MNcnNotificationObserver& aObserver )

	{

	CNcnSession* self = 

	    new( ELeave ) CNcnSession( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

// CNcnSession::ServiceL

//

// ServiceL method from CSession2.

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

//

void CNcnSession::ServiceL( const RMessage2& aMessage )

    {

    // If this method leaves default ServiceError implementation will

    // complete the message using the leave value.

    // However, we have to reset our member variable in any case so

    // we can't rely on this functionality, hence the trap below    

    if( IsRequestPending() )

        {

        PanicClient( aMessage, EPanicNcnRequestActive );

        }

    // set current request message

    SetRequestMessage( aMessage );    

    // handle service inside a trap so we can

    // reset our message member if service leaves

    TRAPD( error, HandleServiceL( aMessage ) );

    // complete & reset current message

    CompleteRequestMessage( error );

    }    

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

// CNcnSession::HandleServiceL

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

//    

void CNcnSession::HandleServiceL( const RMessage2& aMessage )

    {

    switch ( aMessage.Function() )

        {

        case ENewInternalMessages1:

            {

            ServiceNewInternalMessages1L( aMessage );            

            break;

            }

        case ENewInternalMessages2:

            {

            ServiceNewInternalMessages2L( aMessage );

            break;

            }

        case EInternalMarkUnread1:

            {

            ServiceInternalMarkUnread1L( aMessage );

            break;

            }

        case EInternalMarkUnread2:

            {

            ServiceInternalMarkUnread2L( aMessage );

            break;

            }

        case EInternalCancelMarkUnread:

            {

            CancelRequest();

            break;            

            }

        case ENewMessages1:

            {

            ServiceNewMessages1L( aMessage );

            break;

            }

        case EMarkUnread1:

            {

            ServiceMarkUnread1L( aMessage );

            break;

            }             

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    }

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

// CNcnSession::CompleteRequestMessage

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

//    

void CNcnSession::CompleteRequestMessage( TInt aError )

    {

    // if request message is set complete it with error code

    if( !iRequestMessage.IsNull() )

        {

        iRequestMessage.Complete( aError );

        }

    }

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

// CNcnSession::SetRequestMessage

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

//        

void CNcnSession::SetRequestMessage( const RMessage2& aMessage )

    {

    iRequestMessage = aMessage;

    }

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

// CNcnSession::IsRequestPending

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

//

TBool CNcnSession::IsRequestPending() const

    {

    return !iRequestMessage.IsNull();

    }

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

// CNcnSession::CancelRequest

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

//

void CNcnSession::CancelRequest()

    {

    // complete pending request with KErrCancel

    CompleteRequestMessage( KErrCancel );

    }

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

// CNcnSession::PanicClient

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

//    

void CNcnSession::PanicClient( const RMessage2& aMessage, TNcnSessionPanic aPanic )

    {

    _LIT( KPanicCategory, "ncnsession" );

    aMessage.Panic( KPanicCategory, aPanic );

    }

void CNcnSession::ServiceNewInternalMessages1L( const RMessage2& aMessage )

    {    

    TNcnNotifMessageType type =

        static_cast <TNcnNotifMessageType> ( aMessage.Int0() );

    iObserver.HandleNewInternalMessagesL( type );

    }

void CNcnSession::ServiceNewInternalMessages2L( const RMessage2& aMessage )

    {     

    TNcnNotifMessageType type =

        static_cast <TNcnNotifMessageType> ( aMessage.Int0() );

    TMsvId mailBox = static_cast <TMsvId> ( aMessage.Int1() );            

    CNcnUnpackDescrArray* packedInfo = CNcnUnpackDescrArray::NewLC();

    packedInfo->UnpackL( aMessage, 2 );

    iObserver.HandleNewInternalMessagesL( type, mailBox, *packedInfo );

    CleanupStack::PopAndDestroy( packedInfo );

    }       

void CNcnSession::ServiceInternalMarkUnread1L( const RMessage2& aMessage )

    {    

    TNcnUnreadRequestType type =

        static_cast <TNcnUnreadRequestType> ( aMessage.Int0() );

    iObserver.HandleInternalMarkUnreadL( type );

    }    

void CNcnSession::ServiceInternalMarkUnread2L( const RMessage2& aMessage )

    {    

    TNcnUnreadRequestType type =

        static_cast <TNcnUnreadRequestType> ( aMessage.Int0() );

    TMsvId mailBox = static_cast <TMsvId> ( aMessage.Int1() );        

    iObserver.HandleInternalMarkUnreadL( type, mailBox );

    }

void CNcnSession::ServiceNewMessages1L( const RMessage2& aMessage )

    {    

    TMsvId mailBox = static_cast <TMsvId> ( aMessage.Int0() );

    MNcnNotification::TIndicationType indicationType =

        static_cast <MNcnNotification::TIndicationType> ( aMessage.Int1() );

    CNcnUnpackDescrArray* packedInfo = CNcnUnpackDescrArray::NewLC();

    packedInfo->UnpackL( aMessage, 2 );

    iObserver.HandleNewMessagesL( mailBox, indicationType, *packedInfo );

    CleanupStack::PopAndDestroy( packedInfo );

    }

void CNcnSession::ServiceMarkUnread1L( const RMessage2& aMessage )

    {

    TMsvId mailBox = static_cast <TMsvId> ( aMessage.Int0() );        

    iObserver.HandleMarkUnreadL( mailBox );    

    }

// End of file