/*

* 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 plugin proxy implementation

*

*/

#include <ecom/ecom.h>

#include "sensrvdefines.h"

#include "sensrvpluginproxy.h"

#include "sensrvproxymanager.h"

#include "sensrvtransaction.h"

#include "sensrvtransactionqueue.h"

#include "sensrvtransactionmonitor.h"

#include "senserverchannel.h"

#include "sensrvssymediator.h"

#include "sensrvservermediator.h"

#include "sensrvssyactivescheduler.h"

#include "sensrvclientserver.h"

#include "sensrvthreadmonitor.h"

#include "sensrvchanneldatareader.h"

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

// 2-phase constructor

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

//

CSensrvPluginProxy* CSensrvPluginProxy::NewL(CSensrvProxyManager& aParent,

                         TUid aImplementationUid)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::NewL(<proxymanager>, aImplementationUid: 0x%x)" ), aImplementationUid.iUid ) );

    CSensrvPluginProxy* self = new( ELeave ) CSensrvPluginProxy(aParent, aImplementationUid);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// C++ constructor

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

//

CSensrvPluginProxy::CSensrvPluginProxy(CSensrvProxyManager& aParent,

                                       TUid aImplementationUid)

        : iPluginState( EPluginStateUninitialized ),

          iProxyManager(aParent),

          iImplementationUid(aImplementationUid)

    {

    // Nothing to do

    }

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

// 2nd phase of construction

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

//

void CSensrvPluginProxy::ConstructL()

    {

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

    // Init mutex

    User::LeaveIfError(iMutex.CreateLocal());

    iMutex.Wait();

    iLoadWaitQueue = CSensrvTransactionQueue::NewL(ETrue);

    iTransactionMonitor = CSensrvTransactionMonitor::NewL(*this);

    // Note: Slight memory savings are possible if iThreadMonitor and iUnloadTimer

    // are created and deleted alongside SSY thread. However, since the timer events

    // in these classes initiate cleanup, it is not trivial. Maybe server mediator

    // could be utilized for delayed cleanup of these classes?

    iThreadMonitor = CSensrvThreadMonitor::NewL(*this);

    iUnloadTimer = CSensrvTimer::NewL(*this,

                                      iProxyManager.SsyInactivityPeriod(),

                                      CSensrvTimer::ETimerIdSsyInactivityTimer);

    iMutex.Signal();

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

    }

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

// Destructor

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

//

CSensrvPluginProxy::~CSensrvPluginProxy()

    {

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

    iMutex.Wait();

    delete iThreadMonitor;

    delete iTransactionMonitor;

    delete iServerMediator;

    delete iSsyMediator;

    // Cleanup channels

    TInt count = iChannelList.Count();

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

        {

        delete iChannelList[i];

        }

    iChannelList.Reset();

    iChannelInfoList.Reset();

    iRemovedChannelsInfoList.Reset();

    iDynamicChannelInfoList.Reset();

    delete iLoadWaitQueue;

    delete iUnloadTimer;

    iMutex.Signal();

    iMutex.Close();

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

    }

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

// Completes the transaction and calls handling for next one in queue.

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

//

void CSensrvPluginProxy::TransactionHandledAtSsy(CSensrvTransaction* aTransaction)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::TransactionHandledAtSsy(aTransaction: 0x%x)" ), aTransaction ) );

    // Handle transaction according to transaction type

    if (aTransaction)

        {

        // Route transaction finalization according to transaction type

        switch(aTransaction->Type())

            {

            // Proxy level transactions handled here

            case CSensrvTransaction::ETransTypeLoadSsy:

            case CSensrvTransaction::ETransTypeMediatorChannelsChanged:

                {

                CompleteTransaction(aTransaction);

                }

                break;

            // Channel level transactions handled in corresponding channel object.

            case CSensrvTransaction::ETransTypeOpenChannel:

            case CSensrvTransaction::ETransTypeCloseChannel:

            case CSensrvTransaction::ETransTypeStartListening:

            case CSensrvTransaction::ETransTypeStopListening:

            case CSensrvTransaction::ETransTypeMediatorNewDataAvailable:

            case CSensrvTransaction::ETransTypeGetProperty:

            case CSensrvTransaction::ETransTypeGetAllProperties:

            case CSensrvTransaction::ETransTypeSetProperty:

            case CSensrvTransaction::ETransTypeStartConditionListening:

            case CSensrvTransaction::ETransTypeStopConditionListening:

            case CSensrvTransaction::ETransTypeMediatorPropertyChanged:

            case CSensrvTransaction::ETransTypeMediatorForceChannelClose:

                {

                // These transactions must always have valid channel object.

                __ASSERT_ALWAYS(aTransaction->Channel(), User::Panic(KSensrvPanicCategory, ESensrvPanicNullChannel));

                aTransaction->Channel()->CompleteTransaction(aTransaction);

                }

                break;

            default:

                // Unexpected transaction type, so we do not know what to do with it

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::TransactionHandledAtSsy - ERROR: Invalid transaction type" ) ) );

                User::Panic(KSensrvPanicCategory, ESensrvPanicUnknownTransactionType);

                break;

            }

        }

    else

        {

        // NULL transaction used to trigger transaction handling.

        if ( iPluginState == EPluginStateThreadInitializing )

            {

            // Initial notify from SSY thread.

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::TransactionHandledAtSsy - SSY thread initialization completion detected." ) ) );

            SetPluginState(EPluginStateThreadInitialized);

            // Start handling queued transactions

            HandleNextTransaction();

            }

        else if (iPluginState == EPluginStateUnloaded)

            {

            // SSY unloading has finished, handle next transaction if any

            HandleNextTransaction();

            }

        else

            {

            // Can get here if server mediator has been notified,

            // but before its RunL is executed, the only transaction in server mediator's queue

            // is deleted (because of client panic caused session termination, for example).

            // Highly unlikely case, but theoretically possible.

            // In that case we can just ignore the notification.

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::TransactionHandledAtSsy - NULL transaction in an unexpected plugin state: %d" ), iPluginState ) );

            }

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::TransactionHandledAtSsy - return" ) ) );

    }

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

// Initializes plugin mediators and thread,

// loads the plugin and queries for supported channels.

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

//

void CSensrvPluginProxy::InitializePluginL()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL()" ) ) );

    iMutex.Wait();

    iPreviousSsyLoadFailed = EFalse; // Reset SSY load fail indicator

    if (iPluginState != EPluginStateUnloading)

        {

        // Create mutex signaling cleanup item.

        CleanupStack::PushL(

            TCleanupItem( CleanupInitializePlugin, this ) );

        // Create Ssy thread

        // Use unique identifier generated by proxy manager to name thread

        // so that name is guaranteed unique, yet recognizable.

        HBufC* buf = HBufC::NewLC(KSensrvSsyThreadNameMaxLen);

        buf->Des().Append(KSensrvSsyThreadNameBase);

        TInt err(KErrAlreadyExists);

        while (err == KErrAlreadyExists)

            {

            buf->Des().AppendNum(iProxyManager.GenerateUniqueId());

            err = iSsyThread.Create(*buf,

                                    SsyThreadFunction,

                                    ProxyManager().SsyStackSize(),

                                    KSensrvSsyHeapInitialSize,

                                    ProxyManager().SsyHeapMaxSize(),

                                    (TAny*)this);

            if (err == KErrAlreadyExists)

                {

                COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL - Thread name is already in use, recreating..." ) ) );

                }

            buf->Des().Delete(KSensrvSsyThreadNameBaseLen, KSensrvSsyThreadNameMaxLen);

            }

        if (err != KErrNone)

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL - Error creating thread." ) ) );

            User::Leave(err);

            }

        CleanupStack::PopAndDestroy(buf);

        // start monitoring the thread

        User::LeaveIfError(iThreadMonitor->StartMonitoring(iSsyThread));

        // If InitializePluginL leaves, thread monitor triggered cleanup will set state again

        SetPluginState(EPluginStateThreadInitializing);

        // SSY mediator is created here but initialized by SSY thread as it needs current thread handle.

        iSsyMediator = CSensrvSsyMediator::NewL(this);

        // Create and initialize server mediator if not yet created

        if (!iServerMediator)

            {

            iServerMediator = CSensrvServerMediator::NewL(this);

            User::LeaveIfError(iServerMediator->Initialize());

            // Note: SSY mediator is initialized by SSY thread

            }

        // Initially there are no channel change listeners concerning this proxy

        iChannelChangeListenerCount = 0;

        // Create transaction for loading plugin.

        CSensrvTransaction* loadTransaction = NULL;

        loadTransaction = CSensrvTransaction::NewL(

            NULL,

            this,

            NULL,

            CSensrvTransaction::ETransTypeLoadSsy);

        // Add transaction to the beginning of the queue

        err = QueueTransaction(loadTransaction, EFalse);

        if (err == KErrNone)

            {

            // Resume Ssy thread. Must be last thing to do in this method

            // so that nothing else can leave after this.

            iSsyThread.Resume();

            }

        else

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL - ERROR: Failed to queue load transaction %d" ), err ) );

            // Cleanup transaction

            loadTransaction->SetErrorCode(err);

            loadTransaction->Complete();

            delete loadTransaction;

            User::Leave(err);

            }

        CleanupStack::Pop(); // CleanupInitializePlugin

        }

    else

        {

        TInt err = EnqueueDelayedInitializeTransaction();

        if (err == KErrNone)

            {

            // Handle delayed initialize immediately, if already fully unloaded

            if (iPluginState == EPluginStateUnloaded)

                {

                HandleNextTransaction();

                }

            }

        else

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL - ERROR: Failed to queue delayed initialize %d" ), err ) );

            iPreviousSsyLoadFailed = ETrue;

            User::Leave(err);

            }

        }

    iMutex.Signal();

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializePluginL - return" ) ) );

    }

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

// Initializes plugin channel data.

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

//

TInt CSensrvPluginProxy::InitializeChannelData( const CImplementationInformation& aImplInfo )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializeChannelDataL" ) ) );

    TSensrvChannelDataReader reader;

    TInt err = reader.ReadChannels( aImplInfo, iChannelInfoList, iDynamicChannelInfoList );

    if ( err == KErrNone )

        {

        // Generate unique IDs for static channels now. IDs for dynamic channels are handled by SSY channel registration.

        TInt count( iChannelInfoList.Count() );

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

            {

            TSensrvChannelId newId = static_cast<TSensrvChannelId>(ProxyManager().GenerateUniqueId());

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializeChannelDataL - plugin UID: 0x%x channel: %d" ),

                aImplInfo.ImplementationUid().iUid, newId ) );

            iChannelInfoList[i].iChannelId = newId;

            }

        }

    iIsInitialized = ETrue; // even though thread not setup and plugin not laoded yet.

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::InitializeChannelDataL - err %d, return" ), err ) );

    return err;

    }

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

// Handles client message.

// All messages coming from client to proxy target specific channel,

// so pass the message to correct channel object.

// Proxy manager makes sure that messages dispatched to each proxy

// actually target a channel provided by that proxy, so no rechecking is done.

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

//

void CSensrvPluginProxy::DispatchMessage(CSensrvMessage& aMessage,

                                         TSensrvChannelId aChannelId)

    {

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

    iMutex.Wait();

    TInt err(KErrNone);

    TBool completeMessageOnError(ETrue);

    // Check state

    if (iDeletionFlag)

        {

        // If proxy is marked for deletion, do not allow further messages

        err = KErrNotFound;

        }

    else

        {

        if (iPluginState == EPluginStateLoaded)

            {

            // Get channel and pass message there

            CSensrvChannel* channel = GetChannelForId(aChannelId);

            // Special case: When opening channel, create channel if it is not found

            if (aMessage.Function() == ESensrvSrvReqOpenChannel && !channel)

                {

                // Get channel info

                TSensrvChannelInfo* info = GetChannelInfoForId(aChannelId);

                if (info)

                    {

                    TRAPD(err, channel = CSensrvChannel::NewL(*info, *this));

                    if (err == KErrNone)

                        {

                        // Add channel to channel list

                        err = iChannelList.Append(channel);

                        if (err != KErrNone)

                            {

                            delete channel;	// Deleting the channel that is allocated on the heap in case Append Failure.

                            channel = NULL;

                            ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - ERROR: Failed to append channel to array: %d" ), err ) );

                            }

                        }

                    else

                        {

                        ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - ERROR: Failed to create channel: %d" ), err ) );

                        }

                    }

                else

                    {

                    ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - ERROR: No channel info found" ) ) );

                    err = KErrNotFound;

                    }

                }

            if (err == KErrNone)

                {

                if (channel)

                    {

                    channel->DispatchMessage(aMessage);

                    }

                else

                    {

                    // If channel object doesn't exist, something is wrong.

                    ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - ERROR: No channel object" ) ) );

                    err = KErrNotFound;

                    }

                }

            }

        else if (   aMessage.Function() == ESensrvSrvReqOpenChannel

                 && iPluginState != EPluginStateUninitialized )

            {

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - Queuing open channel message" ) ) );

            // If unloading/unloaded, queue initialization transaction.

            if (iPluginState == EPluginStateUnloading || iPluginState == EPluginStateUnloaded)

                {

                err = EnqueueDelayedInitializeTransaction();

                }

            // Queue open transaction into wait queue until plugin can load itself.

            if (err == KErrNone)

                {

                completeMessageOnError = EFalse;

                CSensrvTransaction* transaction = NULL;

                TRAP(err, transaction = CSensrvTransaction::NewL(

                    &aMessage,

                    this,

                    NULL,

                    CSensrvTransaction::ETransTypeDelayedOpenChannel));

                if (err == KErrNone)

                    {

                    err = QueueTransaction(transaction, ETrue);

                    if(err == KErrNone)

                        {

                        // Add transaction to monitor for the duration of the wait.

                        iTransactionMonitor->AddTransaction(transaction);

                        }

                    else

                        {

                        transaction->SetErrorCode(err);

                        transaction->Complete();

                        delete transaction;

                        transaction = NULL;

                        }

                    }

                }

            // Handle delayed initialize immediately, if already fully unloaded

            if (err == KErrNone && iPluginState == EPluginStateUnloaded)

                {

                HandleNextTransaction();

                }

            }

        else

            {

            ERROR_TRACE( ( _L( "Sensor Server - CSensrvPluginProxy::DispatchMessage - ERROR: Plugin in invalid state: %d" ), iPluginState ) );

            err = KErrNotReady;

            }

        }

    if (err != KErrNone && completeMessageOnError)

        {

        aMessage.Complete(err);

        }

    iMutex.Signal();

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

    }

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

// Checks if this proxy supports specified channel

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