/*

* Copyright (c) 2006-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:  Sensor server channel implementation

*

*/

#include <centralrepository.h>

#include "sensrvdefines.h"

#include "senserverchannel.h"

#include "sensrvchannelbuffer.h"

#include "sensrvtransaction.h"

#include "sensrvclientserver.h"

#include "sensrvpluginproxy.h"

#include "sensrvtransactionqueue.h"

#include "sensrvssymediator.h"

#include "sensrvsession.h"

#include "sensrvchannellistener.h"

#include "sensrvservermediator.h"

#include "sensrvtransactionmonitor.h"

#include "sensrvproxymanager.h"

#include "sensrvpropertyqueue.h"

#include "sensrvconditionevaluator.h"

#include "sensrvprivatecrkeys.h"

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

// 2-phase constructor

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

//

CSensrvChannel* CSensrvChannel::NewL( const TSensrvResourceChannelInfo& aInfo,

									  CSensrvPluginProxy& aProxy )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::NewL(aInfo.iChannelId: %d, aProxy: 0x%x)" ), aInfo.iChannelId, aProxy.ImplementationUid().iUid ) );

    CSensrvChannel* self = new( ELeave ) CSensrvChannel( aInfo, aProxy );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::NewL - return 0x%x" ), self ) );

    return self;

    }

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

// C++ constructor

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

//

CSensrvChannel::CSensrvChannel( const TSensrvChannelInfo& aInfo,

                                CSensrvPluginProxy& aProxy )

    : iId( aInfo.iChannelId ),

      iState( EChannelStateClosed ),

      iProxy( aProxy ),

      iChannelInfo( aInfo ),

      iHighestListenerPriority( KMinTInt )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::CSensrvChannel()" ) ) );

    // Nothing to do

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::CSensrvChannel - return" ) ) );

    }

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

// 2nd phase of construction

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

//

void CSensrvChannel::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ConstructL()" ) ) );

    iChannelQueue = CSensrvTransactionQueue::NewL( ETrue );

    iChannelInfo.iChannelGroup = TSensrvResourceChannelInfo::ESensrvChannelGroupNotSolved;

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ConstructL - return" ) ) );

    }

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

// Destructor

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

//

CSensrvChannel::~CSensrvChannel()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::~CSensrvChannel()" ) ) );

    TInt count( iListenerList.Count() );

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

        {

        delete iListenerList[ i ];

        }

    iListenerList.Reset();

    // Remove the first transactions in channel queue from mediator queues and

    // transaction monitor, too. Rest of the queued transactions cannot be

    // queued anywhere else, so no need to check them.

    CSensrvTransaction* firstTransaction = NULL;

    if ( iChannelQueue )

        {

        firstTransaction = iChannelQueue->First();

        }

    if ( iProxy.ServerMediator() )

        {

        iProxy.ServerMediator()->RemoveSingleTransaction( firstTransaction );

        }

    if ( iProxy.SsyMediator() )

        {

        iProxy.SsyMediator()->RemoveSingleTransaction( firstTransaction );

        }

    if ( iProxy.TransactionMonitor() )

        {

        iProxy.TransactionMonitor()->RemoveTransaction( firstTransaction );

        }

    delete iChannelQueue;

    delete iChannelBuffer;

    delete iDataAvailableTransaction;

    delete iForceBufferFilledTransaction;

    delete iForceChannelCloseTransaction;

    delete iPropertyChangedTransaction;

    delete iConditionEvaluator;

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::~CSensrvChannel - return" ) ) );

    }

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

// Handles message according to message type

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

//

void CSensrvChannel::DispatchMessage( CSensrvMessage& aMessage )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::DispatchMessage(aMessage.Function(): %d)" ), aMessage.Function() ) );

    TInt err( KErrNone );

    CSensrvTransaction* transaction = NULL;

    CSensrvTransaction::TSensrvTransactionType transType( CSensrvTransaction::ETransTypeNone );

    // Check command code and call appropriate function

    switch ( aMessage.Function() )

        {

        case ESensrvSrvReqOpenChannel:

            {

            transType = CSensrvTransaction::ETransTypeOpenChannel ;

            break;

            }

        case ESensrvSrvReqCloseChannel:

            {

            transType = CSensrvTransaction::ETransTypeCloseChannel ;

            break;

            }

        case ESensrvSrvReqStartListening:

            {

            transType = CSensrvTransaction::ETransTypeStartListening ;

            break;

            }

        case ESensrvSrvReqStopListening:

            {

            transType = CSensrvTransaction::ETransTypeStopListening ;

            break;

            }

        case ESensrvSrvReqAsyncChannelData:

        case ESensrvSrvReqAsyncPropertyData:

        case ESensrvSrvReqStopPropertyListening:

        case ESensrvSrvReqAddConditionSet:

        case ESensrvSrvReqRemoveConditionSet:

        case ESensrvSrvReqAsyncConditionMet:

            {

            // Get correct listener and pass message there

            CSensrvChannelListener* listener = GetListener( aMessage.Session() );

            if ( listener )

                {

                listener->DispatchMessage( aMessage );

                }

            else

                {

                err = KErrNotFound;

                aMessage.Complete( err );

                }

            break;

            }

        case ESensrvSrvReqGetProperty:

            {

            transType = CSensrvTransaction::ETransTypeGetProperty ;

            break;

            }

        case ESensrvSrvReqSetProperty:

            {

            transType = CSensrvTransaction::ETransTypeSetProperty ;

            break;

            }

        case ESensrvSrvReqGetAllProperties:

            {

            transType = CSensrvTransaction::ETransTypeGetAllProperties ;

            break;

            }

        case ESensrvSrvReqStartConditionListening:

            {

            transType = CSensrvTransaction::ETransTypeStartConditionListening ;

            break;

            }

        case ESensrvSrvReqStopConditionListening:

            {

            transType = CSensrvTransaction::ETransTypeStopConditionListening ;

            break;

            }

        // Cannot identify the message

        default:

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvChannel::DispatchMessage - ERROR: unknown command" )) );

            aMessage.Complete( KErrArgument );

            break;

            }

        }

    //Construct Transaction

    if( transType != CSensrvTransaction::ETransTypeNone )

        {

        TRAP( err, transaction = CSensrvTransaction::NewL(

                    &aMessage,

                    &iProxy,

                    this,

                    transType) );

        // Queue transaction

        if ( transaction && err == KErrNone )

            {

            transaction->SetState( CSensrvTransaction::ETransStateQueued );

            err = iChannelQueue->Add( transaction );

            }

        }

    // Handle error

    if ( err != KErrNone )

        {

        if ( transaction )

            {

            transaction->SetErrorCode( err );

            transaction->Complete();

            delete transaction;

            transaction = NULL;

            }

        else

            {

            // Do nothing, message gets deleted and completed with error

            // on transaction cleanup in cases where transaction creation failed.

            }

        }

    else

        {

        HandleNextTransaction();

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::DispatchMessage - return" ) ) );

    }

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

// Channel opened by SSY, check that providers are correctly set and

// complete the transaction.

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

//

void CSensrvChannel::ChannelOpened(TInt aErrorCode,

                                   MSsyChannelDataProvider* aDataProvider,

                                   MSsyPropertyProvider* aSensorPropertyProvider)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelOpened(aErrorCode: %d)" ), aErrorCode ) );

    TInt err( aErrorCode );

    TInt propErr( KErrNone );

    // If no error, set state to open, if not supported, need to solve dependent channels later

    if ( err == KErrNone || err == KErrNotSupported )

        {

        __ASSERT_ALWAYS( aDataProvider && aSensorPropertyProvider,

                         User::Panic( KSensrvPanicCategory, ESensrvPanicNullProvider ) );

        iDataProvider = aDataProvider;

        iPropertyProvider = aSensorPropertyProvider;

        // Get data rate for determining maximum buffering count

        TSensrvProperty property( KSensrvPropIdDataRate, KSensrvItemIndexNone, 0 );

        TRAP(propErr, iPropertyProvider->GetPropertyL( iId, property ) );

        if ( propErr == KErrNone )

            {

            TInt maxRate( 0 );

            if ( ESensrvArrayPropertyInfo == property.GetArrayIndex() )

                {

                //Array property

                TInt maxValueIndex( 0 );

                property.GetMaxValue( maxValueIndex );

                property.SetItemIndex( KSensrvItemIndexNone ); //Initialize

                property.SetArrayIndex( maxValueIndex ); //Set array index for filter criteria

                TRAP( propErr, iPropertyProvider->GetPropertyL( iId, property ) );

                property.GetValue( maxRate );

                }

            else

                {

                property.GetMaxValue( maxRate );

                }

            if ( propErr == KErrNone )

                {

                iMaxBufferingCount = iProxy.ProxyManager().BufferSizeMultiplier()

                                     * maxRate

                                     / KSensrvDataBufferLengthMultiplier;

                // Very small buffers still need buffering count of at least one

                if ( iMaxBufferingCount < KSensrvMinimumBufferingCount )

                    {

                    iMaxBufferingCount = KSensrvMinimumBufferingCount;

                    }

                }

            else

                {

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelOpened - ERROR: Unable to get maximum data rate from array, using default buffer max size. Error: %d" ), propErr ) );

                iMaxBufferingCount = KSensrvDefaultMaxBufferingCount;

                }

            }

        else

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelOpened - ERROR: Unable to get maximum data rate, using default buffer max size. Error: %d" ), propErr ) );

            iMaxBufferingCount = KSensrvDefaultMaxBufferingCount;

            }

        iState = EChannelStateOpen;

        }

    CSensrvTransaction* transaction = iChannelQueue->First();

    // Unexpected callbacks from SSY mean that executing transaction has been cleaned,

    // so we should not set the error code or notify server mediator

    if (   transaction

       && transaction->Type() == CSensrvTransaction::ETransTypeOpenChannel

       && transaction->State() == CSensrvTransaction::ETransStateHandledAtSsy )

        {

        if ( err != KErrNone && err != KErrNotSupported )

            {

            transaction->SetErrorCode( err );

            }

        // Notify server thread that transaction is complete

        // Error can be ignored, since we are at SSY thread

        iProxy.ServerMediator()->Notify( transaction );

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelOpened - Transaction cleaned already" ) ) );

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelOpened - return" ) ) );

    }

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

// Channel closed by SSY. Cleanup channel and complete the transaction.

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

//

void CSensrvChannel::ChannelClosed()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelClosed()" ) ) );

    iState = EChannelStateClosed;

    CSensrvTransaction* transaction = iChannelQueue->First();

    // Unexpected callbacks from SSY mean transaction has been cleaned, so we should not

    // notify server mediator

    if (  transaction

       && transaction->Type()  == CSensrvTransaction::ETransTypeCloseChannel

       && transaction->State() == CSensrvTransaction::ETransStateHandledAtSsy )

        {

        // Notify server thread that transaction is complete

        // Error can be ignored, since we are at SSY thread

        iProxy.ServerMediator()->Notify( transaction );

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::ChannelClosed - return" ) ) );

    }

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

// Availability has changed. Handle it.

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

//

void CSensrvChannel::HandleAvailabilityChange( const TSensrvProperty& aProperty )

	{

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange()" ) ) );

	TInt propValue;

	aProperty.GetValue( propValue );

	HandleAvailabilityChange( static_cast<TSensrvAvailability>( propValue ) );

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange - return" ) ) );

	}

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

// Availability has changed. Handle it.

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

//

void CSensrvChannel::HandleAvailabilityChange( const TSensrvAvailability& value )

	{

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange()" ) ) );

	switch( value )

		{

		// Channel level transactions handled here

		case ESensrvAvailabilityFalse:

			COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange - Availability changed to ESensrvAvailabilityFalse" ) ) );

			SetChannelUnavailable();

			break;

		case ESensrvAvailabilityTrue:

			COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange - Availability changed to ESensrvAvailabilityTrue" ) ) );

			SetChannelAvailable();

			break;

		default:

		    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange - Incorrect value received for Availability, Value ignored" ) ) );

		    break;

		}

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::HandleAvailabilityChange - return" ) ) );

	}

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

// Availability has changed. Handle it.

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

//

void CSensrvChannel::SetChannelAvailable( )

	{

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::SetChannelAvailable()" ) ) );

	//start channel data

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::SetChannelAvailable - return" ) ) );

	}

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

// Availability has changed. Handle it.

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

//

void CSensrvChannel::SetChannelUnavailable( )

	{

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::SetChannelUnavailable()" ) ) );

	COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::SetChannelUnavailable - return" ) ) );

	}

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

// Property has changed. Store changed property to property queue.

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

//

TBool CSensrvChannel::StoreChangedProperty( const TSensrvProperty& aProperty,

                                            const CSensrvSession* aIgnoreSession )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::StoreChangedProperty(aProperty.GetPropertyId() 0x%x, aIgnoreSession: 0x%x)" ), aProperty.GetPropertyId(), aIgnoreSession ) );

	TBool retval( EFalse );

	TInt propertyId = aProperty.GetPropertyId();

	if ( ( propertyId == KSensrvPropIdAvailability ) )

		{

		COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::StoreChangedProperty - server property changed: %d" ), propertyId ) );

		HandleAvailabilityChange( aProperty );

		}

	TInt i( iListenerList.Count() );

	TInt err( KErrNone );

	for (i--; i >= 0; i--)

		{

		if ( &( iListenerList[ i ]->Session()) != aIgnoreSession )

			{

			err = iListenerList[ i ]->StoreChangedProperty( aProperty );

			if ( err != KErrNone )

				{

				// Probably OOM. Not critical to lose property change notification.

				ERROR_TRACE( ( _L( "Sensor Server - CSensrvChannel::StoreChangedProperty - ERROR: Error while adding property change to listener queue: %d" ), err ) );

				}

			else

				{

				retval = ETrue;

				}

			}

		}

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::StoreChangedProperty - return: %d" ), retval ) );

    return retval;

    }

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

// Handles transaction finalization and completes transaction on channels's queue.

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

//

void CSensrvChannel::CompleteTransaction( CSensrvTransaction* aTransaction )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvChannel::CompleteTransaction(aTransaction: 0x%x)" ), aTransaction ) );

    __ASSERT_ALWAYS( aTransaction, User::Panic( KSensrvPanicCategory, ESensrvPanicNullTransaction ) );