/*

* Copyright (c) 2007 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:  Location Centre Server side session object.

*

*/

// SYSTEM INCLUDES

#include <s32mem.h>

// USER INCLUDES

#include "lcserversession.h"

#include "lcserver.h"

#include "lcipcparams.h"

#include "lcserverinterface.h"

#include "lcserverengine.h"

#include "lcdebug.h"

// ----- Member funtions for CLcServerSession ---------------------------------

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

// CLcServerSession::CLcServerSession

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

//

CLcServerSession::CLcServerSession( CLcServer&        aLcServer,

                                    CLcServerEngine&  aLcServerEngine )

    :iLcServer( aLcServer ),

    iEngine( aLcServerEngine )

    {

    // C++ Default constructor. No allocations or functions which can Leave

    // should be called from here.

    }

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

// CLcServerSession::~CLcServerSession

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

//

CLcServerSession::~CLcServerSession()

    {

    // C++ Destructor. Free all resources associated with this class.

    // Complete the Observer method with KErrServerTerminated if it exists

    if ( iNotificationOutStanding )

        {

        iObserverMessage.Complete( KErrServerTerminated );

        }

    // Decrement the count only if it has been incremented in the Construction

    if( iDecrementSession )

        {

        iLcServer.DecrementSessions();

        }

    }

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

// CLcServerSession* CLcServerSession::NewL

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

//

CLcServerSession* CLcServerSession::NewL( CLcServer&        aLcServer,

                                          CLcServerEngine&  aLcServerEngine )

    {

    CLcServerSession* self = NewLC( aLcServer, aLcServerEngine );

    CleanupStack::Pop( self );

    return self;         

    }

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

// CLcServerSession* CLcServerSession::NewLC

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

//

CLcServerSession* CLcServerSession::NewLC( CLcServer&        aLcServer,

                                           CLcServerEngine&  aLcServerEngine )

    {

    // Symbian Two phased constructor. Leaves the object on the Clean-up

    // stack.

    CLcServerSession* self = 

                        new ( ELeave )CLcServerSession( aLcServer,

                                                        aLcServerEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;         

    }

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

// void CLcService::ConstructL

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

//

void CLcServerSession::ConstructL()

    {

    // Increment the server's increment session routine.

    iLcServer.IncrementSessions();

    // Set the flag to mark that the number of sessions have been incremented.

    // This flag is set at the end of the contruction process to ensure that

    // we dont decrement the count in the destructor unless we have actually

    // incremented it. This is necessary because there is a possibility that

    // the ConstructL leaves before incrementing the count.

    iDecrementSession = ETrue;    

    }  

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

// void CLcServerSession::RegistryUpdated

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

//

void CLcServerSession::RegistryUpdated()

    {

    DEBUG( "+ CLcServerSession::RegistryUpdated")

    // If the Observer has been set, then complete the Observer

    // request with KErrNone.

    if ( iNotificationOutStanding )

        {

        DEBUG3("Notify Client", 0, 0, 0 );

        iObserverMessage.Complete( KErrNone );

        }

    else

        {

        DEBUG3("Notify Lost", 0, 0, 0 );

        iNotifyPending = ETrue;

        }        

    iNotificationOutStanding = EFalse;

    DEBUG( "- CLcServerSession::RegistryUpdated")

    }

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

// void CLcServerSession::ServiceL

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

//

void CLcServerSession::ServiceL( const RMessage2& aMessage )

    {

    DEBUG( "+ CLcServerSession::ServiceL")

    switch( aMessage.Function())

        {

        case ERegisterObserver:

            {

            DEBUG( "Message : ERegisterObserver")

            // If an Observer message exists then this is a Duplicate request

            // which is not accepted.

            if ( iNotificationOutStanding )

                {

                DEBUG3("Notify Already there", 0, 0, 0 );

                aMessage.Complete( KErrAlreadyExists );

                }

            else if ( iNotifyPending )

                {

                DEBUG3("Notify Immediately", 0, 0, 0 );

                aMessage.Complete( KErrNone );

                iNotifyPending = EFalse;

                }

            else

                {

                DEBUG3("Notify Later", 0, 0, 0 );

                // The Client application has requested for an Observer to

                // notify about any changes to the Location Centre Registry.

                // Store the message object.

                iObserverMessage = aMessage;

                iNotificationOutStanding = ETrue;                

                }            

            break;

            }

        case ERemoveObserver:

            {

            DEBUG( "Message : ERemoveObserver")

            // If the Observer has been set, then complete the Observer

            // request with KErrCancel.

            if ( iNotificationOutStanding )

                {

                iObserverMessage.Complete( KErrCancel );

                }

            iNotificationOutStanding = EFalse;

            // Complete the current request with KErrNone

            aMessage.Complete( KErrNone );

            break;

            }

        case ELcFilteredAppsBufferLength:

        case ELcFilteredApps:

        case ELcSpecifiedAppsBufferLength:

        case ELcSpecifiedApps:

        case ELcAppInfoLength:

        case ELcAppInfo:

            {

            TInt desLength = aMessage.GetDesLength( 0 );

            if ( desLength < KErrNone )

                {

                User::Leave( desLength );

                }

            if ( desLength >= KMaxTInt/2 )

                {

                User::Leave( KErrArgument );

                }

            // These messages are not handled here but only in the Engine

            // class. Hence, pass it onto the Engine class for handling.

            iEngine.DoServiceL( aMessage );   

            break;

            }

        default:

            {

            aMessage.Complete( KErrNotSupported );

            }

        }

    DEBUG( "- CLcServerSession::ServiceL")

    }

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

// void CLcServerSession::ServiceError

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

//

void CLcServerSession::ServiceError( const RMessage2& aMessage, 

                                           TInt       aError )

    {

    DEBUG( "+ CLcServerSession::ServiceError")

    aMessage.Complete( aError );

    DEBUG( "- CLcServerSession::ServiceError")

    }

// End of File