/*

* 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:  Mediates control flow from server main thread to plugin thread

*

*/

#include "sensrvdefines.h"

#include "sensrvssymediator.h"

#include "sensrvservermediator.h"

#include "sensrvpluginproxy.h"

#include "sensrvtransaction.h"

#include "ssycontrol.h"

#include "senserverchannel.h"

#include "sensrvproxymanager.h"

#include "sensrvchannelbuffer.h"

#include "sensrvtransactionqueue.h"

#include "sensrvclientserver.h"

// For tracing channel info contents

#ifdef ERROR_TRACE_DEBUG

static void TraceChannelInfo( const TDesC& aPrefix, const TSensrvChannelInfo& aInfo )

    {

    TBuf<KSensrvLocationLength> location;

    location.Copy( aInfo.iLocation );

    TBuf<KSensrvVendorIdLength> vendor;

    vendor.Copy( aInfo.iVendorId );

    ERROR_TRACE( ( _L("%S iChannelId=%d, iContextType=%d, iQuantity=%d, iChannelType=%d, iLocation=%S, iVendorId=%S, iDataItemSize=%d, iChannelDataTypeId=%d"),

        &aPrefix,aInfo.iChannelId,aInfo.iContextType,aInfo.iQuantity,aInfo.iChannelType,&location,&vendor,aInfo.iDataItemSize,aInfo.iChannelDataTypeId ) );

    }

#define ERROR_TRACE_CHANNELINFO( aPrefix, aChannelInfo ) TraceChannelInfo( aPrefix, aChannelInfo )

#else // ERROR_TRACE_DEBUG

#define ERROR_TRACE_CHANNELINFO( aPrefix, aChannelInfo )

#endif // ERROR_TRACE_DEBUG

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

// 2-phase constructor

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

//

CSensrvSsyMediator* CSensrvSsyMediator::NewL(CSensrvPluginProxy* aProxy)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::NewL(aProxy: 0x%x)" ), aProxy->ImplementationUid().iUid ) );

    __ASSERT_ALWAYS(aProxy, User::Panic(KSensrvPanicCategory, ESensrvPanicNullProxy));

    CSensrvSsyMediator* self = new( ELeave ) CSensrvSsyMediator();

    CleanupStack::PushL( self );

    self->BaseConstructL(aProxy);

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// C++ constructor

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

//

CSensrvSsyMediator::CSensrvSsyMediator()

    : iUnloading(EFalse)

    {

    // Nothing to do

    }

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

// 2nd phase of construction

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

//

void CSensrvSsyMediator::ConstructL()

    {

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

    // Create ETransTypeMediatorChannelsChanged transaction here so we can be sure

    // it is always available in server heap

    iChannelChangeTransaction = CSensrvTransaction::NewL(

        NULL,

        iProxy,

        NULL,

        CSensrvTransaction::ETransTypeMediatorChannelsChanged);

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

    }

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

// Destructor

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

//

CSensrvSsyMediator::~CSensrvSsyMediator()

    {

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

    // NOTE that iSsyControl cannot be deleted here, as this is called from server thread.

    if ( iSsyControl )

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::~CSensrvSsyMediator - iSsyControl still non-NULL at SSY mediator destructor" ) ) );

        // Since mediator has not been cleaned up properly, cancel at destructor will hang,

        // waiting for request completion that will never come. To avoid this,

        // complete request pre-emptively here.

        if ( IsActive() )

            {

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrCancel );

            }

        }

    Destruct();

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

    }

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

// CSensrvSsyMediator::Destruct()

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

//

void CSensrvSsyMediator::Destruct()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::Destruct()" ) ) );

    delete iChannelChangeTransaction;

    iChannelChangeTransaction = NULL;

    if (iProxy && iRawInfos)

        {

        iProxy->ProxyManager().ServerHeap()->Free( iRawInfos );

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::Destruct - return void" ) ) );

    }

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

// Cleanup

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

//

void CSensrvSsyMediator::Cleanup()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::Cleanup(), Mediated thread: %S" ), &iThreadName ) );

    iMutex->Wait(); 

    RemoveAllTransactions();

    if (!iUnloading)

        {

        iUnloading = ETrue;

        // Complete to cause RunL execution in SSY thread, which will then stop

        // SSY scheduler, which will lead to SSY thread termination.

        CompleteRequest(KErrNone);

        }

    iMutex->Signal(); 

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::Cleanup - return" ) ) );

    }

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

// Open channel

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

//

void CSensrvSsyMediator::ChannelOpened( TSensrvChannelId aChannelId,

                                        TInt aErrorCode,

                                        MSsyChannelDataProvider* aChannelDataProvider,

                                        MSsyPropertyProvider* aSensorPropertyProvider )

    {

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelOpened(aChannelID: 0x%x, aErrorCode: %d, aChannelDataProvider: 0x%x, aSensorPropertyProvider: 0x%x )" ), aChannelId, aErrorCode, aChannelDataProvider, aSensorPropertyProvider ) );

    iMutex->Wait();

    // Get channel object

    CSensrvChannel* channel = iProxy->GetChannelForId(aChannelId);

    if ( channel )

        {

        channel->ChannelOpened(aErrorCode, aChannelDataProvider, aSensorPropertyProvider);

        }

    else

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelOpened - ERROR: ChannelOpened for nonexistent channel" ) ) );

        }

    iMutex->Signal();

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelOpened - return" ) ) );

    }

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

// Close channel

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

//

void CSensrvSsyMediator::ChannelClosed( TSensrvChannelId aChannelId)

    {

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelClosed(aChannelId: 0x%x)" ), aChannelId ) );

    iMutex->Wait();

    // Get channel object

    CSensrvChannel* channel = iProxy->GetChannelForId(aChannelId);

    if (channel)

        {

        channel->ChannelClosed();

        }

    else

        {

        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelOpened - ERROR: ChannelClosed for nonexistent channel" ) ) );

        }

    iMutex->Signal();

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::ChannelClosed - return" ) ) );

    }

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

// Request new block from channel buffer and notify server mediator

// that there is new data in buffer.

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

//

void CSensrvSsyMediator::BufferFilled( TSensrvChannelId aChannelId,

                                  TInt aWriteCount,

                                  TUint8*& aNewBuffer,

                                  TInt &aNewCount)

    {

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled(aChannelId: 0x%x, aWriteCount: %d, <newbuffer>, <newcount>), mediated thread: %S" ), aChannelId, aWriteCount, &iThreadName ) );

    iMutex->Wait();

    // Get channel object

    CSensrvChannel* channel = iProxy->GetChannelForId(aChannelId);

    // If aWriteCount is negative, an error has occurred and the channel must be closed

    if (channel)

        {

        CSensrvTransaction* transaction = NULL;

        if (aWriteCount < 0)

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled - ERROR: Negative aWriteCount, channel must be closed: %d" ), aWriteCount ) );

            transaction = channel->ForceChannelCloseTransaction();

            }

        else if (channel->Buffer())

            {

            // Validate buffer block and request new data

            channel->Buffer()->WroteBlock(aWriteCount);

            aNewCount  = channel->RecalculateBufferingCount();

            if (aNewCount)

                {

                aNewBuffer = channel->Buffer()->GetFreeBlock(aNewCount);

                transaction = channel->DataAvailableTransaction();

                }

            else

                {

                // Zero count means no clients, so channel needs to be closed.

                transaction = channel->ForceChannelCloseTransaction();

                }

            }

        else

            {

            // Do nothing, if buffer is not valid

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled - ERROR: Buffer channel doesn't exist." ) ) );

            }

        // Notify server thread that new data was written or close is needed.

        // Note that even if data count was zero, notification is needed.

        if (transaction)

            {

            // No need to add transaction to transaction monitor,

            // because if server main thread causes timeout, we probably have

            // problems that will not be fixed by SSY reloading, and

            // in any case, it is unlikely that monitor will even run.

            TInt err = iProxy->ServerMediator()->Notify(transaction);

            if ( err != KErrNone )

                {

                // Just trace, HandleNotifyFailure will take care of failure handling.

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled - ERROR: Server mediator notify failed: %d" ), err ) );

                }

            }

        }

    else

        {

        // Do nothing, if channel is not valid

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled - Channel has been cleaned up" ) ) );

        }

    iMutex->Signal();

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::BufferFilled - return" ) ) );

    }

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

// CSensrvSsyMediator::PropertyChanged

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

//

void CSensrvSsyMediator::PropertyChanged( const TSensrvChannelId /*aChannelId*/, // aChannelId is not needed

                                          const RSensrvChannelList& aAffectedChannels,

                                          const TSensrvProperty& aProperty )

    {

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::PropertyChanged(<aAffectedChannels>, <propertylist>)" ) ) );

    iMutex->Wait();

    //Go through all affected channels

    for( TInt i=0 ; i<aAffectedChannels.Count() ; i++ )

        {

        // Get channel object

        CSensrvChannel* channel = iProxy->GetChannelForId( aAffectedChannels.operator[]( i ) );

        // Note: It is technically possible that channel object has been deleted because plugin unload

        // due e.g. transaction timeout has just started, although it is highly unlikely.

        if ( channel )

            {

            TBool propNotifyNeeded = channel->StoreChangedProperty( aProperty, NULL );

            if ( propNotifyNeeded )

                {

                CSensrvTransaction* transaction = channel->PropertyChangedTransaction();

                // Notify server thread that a property has been changed.

                if( transaction )

                    {

                    TInt err = iProxy->ServerMediator()->Notify( transaction );

                    if ( err != KErrNone )

                        {

                        // Just trace, HandleNotifyFailure will take care of failure handling.

                        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::PropertyChanged - ERROR: Server mediator notify failed: %d" ), err ) );

                        }

                    }

                }

            }

        else

            {

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::PropertyChanged - Channel has been deleted." ) ) );

            }

        }//for

    iMutex->Signal();

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::PropertyChanged - return" ) ) );

    }

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

// Fetches new unique channel id from proxy manager

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

//

void CSensrvSsyMediator::RegisterChannelsL( RSensrvChannelInfoList& aChannelInfoList)

    {

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL(<infolist>)" ) ) );

    iMutex->Wait();

    TInt err( KErrNone );

    if ( !iUnloading )

        {

        TInt newCount = aChannelInfoList.Count();

        TInt oldCount = iProxy->ChannelInfoList().Count();

        TInt dynamicCount = iProxy->DynamicChannelInfoList().Count();

        TInt ancientCount = iProxy->RemovedChannelsInfoList().Count();

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - SSY: 0x%x Old count: %d, New count: %d, Ancient count %d, Dynamic count %d" ),

            iProxy->ImplementationUid().iUid, oldCount, newCount, ancientCount, dynamicCount ) );

        // Check if old array contains these channels

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

            {

            TSensrvChannelInfo& channelInfo( aChannelInfoList[i] );

            // Ensure that info is complete and the actual data item size is set

            if ( channelInfo.IsComplete() && channelInfo.iDataItemSize > 0 )

                {

                // Set channel id to zero just in case

                channelInfo.iChannelId = 0;

                // Get channel ID from old active channels

                TInt index = CSensrvPluginProxy::FindChannel( channelInfo, iProxy->ChannelInfoList() );

                if ( index >= 0 && index < oldCount )

                    {

                    channelInfo.iChannelId = iProxy->ChannelInfoList()[index].iChannelId;

                    }

                if ( !channelInfo.iChannelId )

                    {

                    index = CSensrvPluginProxy::FindChannel( channelInfo, iProxy->DynamicChannelInfoList() );

                    if ( index >= 0 && index < dynamicCount )

                        {

						channelInfo.iChannelId = iProxy->DynamicChannelInfoList()[index].iChannelId;

						}

					}

                if ( !channelInfo.iChannelId )

                    {

					index = CSensrvPluginProxy::FindChannel( channelInfo, iProxy->RemovedChannelsInfoList() );

					if ( index >= 0 && index < ancientCount )

						{

						channelInfo.iChannelId = iProxy->RemovedChannelsInfoList()[index].iChannelId;

						}

					}

				if ( !channelInfo.iChannelId )

					{

					channelInfo.iChannelId = static_cast<TSensrvChannelId>( iProxy->ProxyManager().GenerateUniqueId() );

					}

				if ( !channelInfo.iChannelId )

					{

					ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Registered channel data (SSY 0x%x channel index: %d) not present in SSY resource" ),

						iProxy->ImplementationUid().iUid, i ) );

					ERROR_TRACE_CHANNELINFO( _L( "Invalid channel info" ), channelInfo );

					err = KErrArgument;

					}

                }

            else

                {

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Incomplete channel data registered (SSY 0x%x channel index: %d)" ),

                    iProxy->ImplementationUid().iUid, i ) );

                ERROR_TRACE_CHANNELINFO( _L( "Incomplete channel info" ), channelInfo );

                err = KErrArgument;

                }

            }

        if ( err == KErrNone )

            {

            // Check if all static channels are registered

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

                {

                const TSensrvResourceChannelInfo& oldInfo(iProxy->ChannelInfoList()[i]);

                if (!oldInfo.iDynamic)

                    {

                    if (CSensrvPluginProxy::FindChannel(aChannelInfoList, oldInfo) == KErrNotFound)

                        {

                        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Channel data (SSY 0x%x channel id: %d channel index: %d) not registered" ),

                            iProxy->ImplementationUid().iUid, oldInfo.iChannelId, i ) );

                        ERROR_TRACE_CHANNELINFO( _L( "Not registered channel info" ), oldInfo );

                        err = KErrArgument;

                        }

                    }

                }

            }

        // Ensure that SSY given channel infos were valid

        __ASSERT_DEBUG( err == KErrNone, User::Panic( KSensrvPanicCategory, ESensrvPanicUnexpectedSsyCallback ) );

        if ( err == KErrNone )

            {

            // Allocate space to proxy's heap for count and infos, and copy info count and raw info data there

            iProxy->ProxyManager().ServerHeap()->Free(iRawInfos);

            TInt rawDataSize(newCount*sizeof(TSensrvChannelInfo));

            iRawInfos = iProxy->ProxyManager().ServerHeap()->Alloc(sizeof(newCount) + rawDataSize);

            if (iRawInfos)

                {

                TUint8* contPtr = Mem::Copy(iRawInfos, &newCount, sizeof(newCount));

                Mem::Copy(contPtr, reinterpret_cast<TAny*>(&(aChannelInfoList[0])), rawDataSize);

                // Notify proxy with ETransTypeMediatorChannelsChanged transaction,

                // unless this is during load (i.e. when iSsyControl is still NULL).

                if (iSsyControl)

                    {

                    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - Notifying proxy with ETransTypeMediatorChannelsChanged" ) ) );

                    err = iProxy->ServerMediator()->Notify(iChannelChangeTransaction);

                    if ( err != KErrNone )

                        {

                        ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Server mediator notify failed for ETransTypeMediatorChannelsChanged: %d" ), err ) );

                        }

                    }

                }

            else

                {

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Failure to copy raw data" ) ) );

                err = KErrNoMemory;

                }

            }

        else

            {

            // Mark proxy as bad and notify to remove its channels before unloading it

            iProxy->SetDeletionFlag();

            if (iSsyControl)

                {

                TInt err2 = iProxy->ServerMediator()->Notify(iChannelChangeTransaction);

                if (err2 != KErrNone)

                    {

                    ERROR_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - ERROR: Server mediator notify failed for ETransTypeMediatorChannelsChanged: %d" ), err2 ) );

                    }

                }

            }

        }

    else

        {

        // Do nothing, cleanup ongoing

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - NULL proxy" ) ) );

        }

    iMutex->Signal();

    // Now that mutex has been signaled, it is ok to leave.

    User::LeaveIfError(err);

    API_TRACE( ( _L( "Sensor Server - CSensrvSsyMediator::RegisterChannelsL - return" ) ) );

    }

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

// Gets callback interface

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