/*

* 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 proxy manager

*

*/

#include <centralrepository.h>

#include "sensrvdefines.h"

#include "sensrvproxymanager.h"

#include "sensrvsession.h"

#include "sensrvserver.h"

#include "sensrvtrace.h"

#include "ssycontrol.h"

#include "sensrvtransactionqueue.h"

#include "sensrvmessage.h"

#include "sensrvclientserver.h"

#include "sensrvtransaction.h"

#include "sensrvtypes.h"

#include "sensrvprivatecrkeys.h"

#ifdef __WINS__

// Multiplier to avoid out of memory in emulator

const TInt KSensrvSsyMaxHeapWinsMultiplier = 2;

#endif // __WINS__

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

// 2-phase constructor

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

//

CSensrvProxyManager* CSensrvProxyManager::NewL(CSensrvServer& aServer)

    {

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

    CSensrvProxyManager* self = new( ELeave ) CSensrvProxyManager(aServer);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// C++ constructor

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

//

CSensrvProxyManager::CSensrvProxyManager(CSensrvServer& aServer)

    : iServer(aServer),

      iTransactionTimeout(KSensrvDefaultTransactionTimeout),

      iSsyStackSize(KSensrvDefaultSsyStackSize),

      iSsyHeapMaxSize(KSensrvDefaultSsyHeapMaxSize),

      iThreadTerminationGracePeriod(KSensrvSsyGracefulCleanupTime),

      iSsyInactivityPeriod(KSensrvSsyInactivityPeriod),

      iBufferSizeMultiplier(KSensrvDefaultDataRateMultiplier),

      iTerminationPeriod(KSensrvDefaultTerminationPeriod)

    {

    // Nothing to do

    }

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

// 2nd phase of construction

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

//

void CSensrvProxyManager::ConstructL()

    {

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

    User::LeaveIfError(iServerThread.Open(iServerThread.Id()));

    iHeap = &User::Heap();

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

    // Get configurable settings

    GetSettings();

    iServerShutdown = CSensrvShutdown::NewL( *this );

    iWaitQueueQueryChannels = CSensrvTransactionQueue::NewL(ETrue);

    iWaitQueueOpenChannel   = CSensrvTransactionQueue::NewL(ETrue);

    // Create ecom changelistener, which will make the initial check for plugins

    iEcomChangeListener = CSensrvEcomChangeListener::NewL(*this);

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

    }

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

// Destructor

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

//

CSensrvProxyManager::~CSensrvProxyManager()

    {

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

    if (iProxyCleaner)

        {

        iProxyCleaner->Cancel();

        delete iProxyCleaner;

        }

    delete iEcomChangeListener;

    // Cleanup iProxyList

    TInt count = iProxyList.Count();

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

        {

        delete iProxyList[i];

        }

    iProxyList.Reset();

    // Cleanup iWaitQueue

    delete iWaitQueueQueryChannels;

    delete iWaitQueueOpenChannel;

    iProxyManagerMutex.Close();

    iServerThread.Close();

    if (iShutdownMessage.Handle())

        {

        iShutdownMessage.Complete(KErrCancel);

        }

    if (iSsyImplInfoArray)

        {

        iSsyImplInfoArray->ResetAndDestroy();

        delete iSsyImplInfoArray;

        }

    delete iServerShutdown;

    // iHeap not owned

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

    }

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

// Handles message according to message type

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

//

void CSensrvProxyManager::DispatchMessage( CSensrvMessage& aMessage )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::DispatchMessage(aMessage.Function(): %d), client SID: 0x%x" ), aMessage.Function(), aMessage.SecureId().iId ) );

    // Check command code and call appropriate function

    switch ( aMessage.Function() )

        {

        case ESensrvSrvReqQueryChannels:

            {

            QueryChannels(aMessage);

            break;

            }

        case ESensrvSrvReqOpenChannel:

            {

            // Get channel ID from message

            // No need to check error value, we already made sure the message function is correct

            TSensrvChannelId channelId(0);

            aMessage.GetChannelId(channelId);

            // Determine which proxy handles this channel

            CSensrvPluginProxy* proxy = GetProxyForChannel(channelId);

            if( proxy != NULL &&

                (proxy->PluginState() == CSensrvPluginProxy::EPluginStateUnloaded ||

                 proxy->PluginState() == CSensrvPluginProxy::EPluginStateUninitialized ) )

                {

                TRAPD(err, proxy->InitializePluginL());

                if ( err != KErrNone )

                    {

                    // If proxy initialization fails, it means that proxy will not provide any channels.

                    // Since SSY thread has not been resumed yet (resume is the last thing in InitializeL), proxy

                    // can be safely deleted without risk for memory leak.

                    ERROR_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::EcomChanged - ERROR: Proxy initialization failed, error %d" ),  err) );

                    TInt pos( iProxyList.Find( proxy ) );

                    delete proxy;

                    proxy = NULL;

                    if ( pos >= 0 && pos < iProxyList.Count() )

                        {

                        iProxyList.Remove(pos);

                        }

                    }

                }

            // Dispatch the message for found proxy to be handled

            if (proxy != NULL)

                {

                proxy->DispatchMessage(aMessage, channelId); // Transfer ownership of message

                }

            else

                {

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::DispatchMessage - ERROR: Proxy not found" )) );

                // Complete with error

                aMessage.Complete(KErrNotFound);

                }

            break;

            }

        case ESensrvSrvReqCloseChannel:

        case ESensrvSrvReqStartListening:

        case ESensrvSrvReqStopListening:

        case ESensrvSrvReqAsyncChannelData:

        case ESensrvSrvReqGetProperty:

        case ESensrvSrvReqSetProperty:

        case ESensrvSrvReqAsyncPropertyData:

        case ESensrvSrvReqStopPropertyListening:

        case ESensrvSrvReqGetAllProperties:

        case ESensrvSrvReqAddConditionSet:

        case ESensrvSrvReqRemoveConditionSet:

        case ESensrvSrvReqStartConditionListening:

        case ESensrvSrvReqStopConditionListening:

        case ESensrvSrvReqAsyncConditionMet:

            {

            // Get channel ID from message

            // No need to check error value, we already made sure the message function is correct

            TSensrvChannelId channelId(0);

            aMessage.GetChannelId(channelId);

            // Determine which proxy handles this channel

            CSensrvPluginProxy* proxy = GetProxyForChannel(channelId);

            // Dispatch the message for found proxy to be handled

            if (proxy != NULL)

                {

                proxy->DispatchMessage(aMessage, channelId); // Transfer ownership of message

                }

            else

                {

                ERROR_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::DispatchMessage - ERROR: Proxy not found" )) );

                // Complete with error

                aMessage.Complete(KErrNotFound);

                }

            break;

            }

        // Cannot identify the message

        default:

            {

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

            aMessage.Complete(KErrArgument);

            break;

            }

        }

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

    }

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

// Generate new unique id.

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

//

TInt CSensrvProxyManager::GenerateUniqueId()

    {

    iProxyManagerMutex.Wait();

    iIdCounter++;

    // Realistically, there will never be so many ids generated that the counter will roll over, but

    // check just in case. No checking for duplicate ids, as chance of that happening is truly

    // astronomical.

    if (iIdCounter == KMaxTInt)

        {

        iIdCounter = 1;

        }

    iProxyManagerMutex.Signal();

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::GenerateUniqueId - generated new id: 0x%x" ), iIdCounter ) );

    return iIdCounter;

    }

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

// Checks waitqueue and if there are queued transactions,

// checks if all proxies have constructed successfully.

// If so, starts executing queued transactions.

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

//

void CSensrvProxyManager::NotifyProxyInitialized()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::NotifyProxyInitialized()") ) );

    TInt count = iProxyList.Count();

    iAllProxiesInitialized = ETrue;

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

        {

        if (!iProxyList[i]->IsInitialized())

            {

            iAllProxiesInitialized = EFalse;

            break;

            }

        }

    if (iAllProxiesInitialized)

        {

        HandleTransactionsQueryChannels();

        HandleTransactionsOpenChannel();

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::NotifyProxyInitialized - All proxies not yet initialized") ) );

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::NotifyProxyInitialized - return" )) );

    }

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

// Duplicates source handle to destination handle.

// Source handle must be held by Server Main Thread

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

//

TInt CSensrvProxyManager::DuplicateMutexHandle(const RMutex& aSrc, RMutex& aDst) const

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::DuplicateMutexHandle(aSrc.Handle(): 0x%x, aDst.Handle(): 0x%x)"),aSrc.Handle(), aDst.Handle() ) );

    aDst.SetHandle(aSrc.Handle());

    TInt err = aDst.Duplicate(iServerThread);

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::DuplicateMutexHandle - return %d" ), err) );

    return err;

    }

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

// shuts down server gracefully

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

//

void CSensrvProxyManager::ShutdownServer(const RMessage2& aMessage)

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer(<RMessage2>)") ) );

    if (iShutdownMessage.Handle())

        {

        // Already shutting down, complete

        aMessage.Complete(KErrNone);

        }

    else

        {

        iShutdownMessage = aMessage;

        ShutdownServer();

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer - return" )) );

    }

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

// shuts down server gracefully

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

//

void CSensrvProxyManager::ShutdownServer()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer()") ) );

    if (!iShutdown)

        {

        iShutdown = ETrue;

        iShuttingDownCount = 0;

        // Cleanup proxies and solve amount of proxies to shutdown

        TInt proxyCount = iProxyList.Count();

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

            {

            // Set deletion flag to disable usage attempts if shutdown was requested by client.

            // Othwerwise usage attempt is allowed to cancel shutdown.

            if (iShutdownMessage.Handle())

                {

                iProxyList[i]->SetDeletionFlag();

                }

            CSensrvPluginProxy::TPluginState pluginState = iProxyList[i]->PluginState();

            if (pluginState == CSensrvPluginProxy::EPluginStateLoaded ||

                pluginState == CSensrvPluginProxy::EPluginStateThreadInitializing ||

                pluginState == CSensrvPluginProxy::EPluginStateThreadInitialized)

                {

                iProxyList[i]->CleanupPlugin();

                iShuttingDownCount++;

                }

            else if (pluginState == CSensrvPluginProxy::EPluginStateUnloading)

                {

                // Plugin already unloading

                iShuttingDownCount++;

                }

            }

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer - proxies to shutdown %d" ),

            iShuttingDownCount ) );

        // Shutdown right away, if no proxies to unload

        if (!iShuttingDownCount)

            {

            SsyThreadTerminated();

            }

        }

    else

        {

        COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer - Already shutting down" )) );

        }

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::ShutdownServer - return" )) );

    }

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

// Handles proxy thread termination

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

//

void CSensrvProxyManager::SsyThreadTerminated()

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::SsyThreadTerminated() shutdown status %d"), iShutdown ) );

    if (iShutdown)

    	{

        if (iShuttingDownCount > 0)

            {

            --iShuttingDownCount;

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::SsyThreadTerminated - proxies left %d "), iShuttingDownCount ) );

            }

        else

            {

            iShuttingDownCount = 0;

            COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::SsyThreadTerminated - Proxies already shutdown") ) );

            }

        if (!iShuttingDownCount)

            {

            if (iShutdownMessage.Handle())

                {

                iShutdownMessage.Complete(KErrNone);

                }

            if (CActiveScheduler::Current())

                {

                CActiveScheduler::Stop();

                CActiveScheduler::Install(NULL);

                }

            }

    	}

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::SsyThreadTerminated - return" )) );

    }

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

// Compares current implementation infos to new implementation infos

// and determines if new proxies need to be loaded or old ones deleted.

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

//

TBool CSensrvProxyManager::EcomChanged( RImplInfoPtrArray* aImplementationInfos )

    {

    COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvProxyManager::EcomChanged(<array>)") ) );

    TBool changes(EFalse);

    TInt i(0);

    TInt j(0);

    TInt found(KErrNotFound);

    TInt err(KErrNone);

    TBool changeOk(ETrue);

    __ASSERT_ALWAYS(aImplementationInfos, User::Panic(KSensrvPanicCategory, ESensrvPanicNullImplInfos));

    // If no array previously registered this is first registration.

    if (!iSsyImplInfoArray)

        {

        // First registration should always have some plugins or it is considered an error, although

        // there might be devices that do not have any sensors as default. Since we only trace the

        // error, this is not a problem.

        if (!aImplementationInfos->Count())

            {

            ERROR_TRACE( ( _L("Sensor Server - CSensrvProxyManager::EcomChanged - Possible ERROR: No SSY plugins found. (This might be ok for some devices with no internal sensors)" ) ) );

            }

        }

    else

        {

        // If still loading initial plugins, do not allow new changes until initial loads have completed.

        if (!iAllProxiesInitialized)

            {

            changeOk = EFalse;

            }

        }

    if (changeOk)

        {

        // Compare current implementation infos to new ones to find new plugins

        for (i = 0; i < aImplementationInfos->Count(); i++)

            {

            found = KErrNotFound;

            // Skip comparisons on the first time when there is no array to compare

            if (iSsyImplInfoArray)

                {

                for (j = 0; found == KErrNotFound && j < iSsyImplInfoArray->Count(); j++)

                    {

                    if ((*iSsyImplInfoArray)[j]->ImplementationUid() == (*aImplementationInfos)[i]->ImplementationUid())

                        {

                        found = j;

                        }

                    }

                }

            // Create and initialize new proxy

            if (found == KErrNotFound)

                {

                changes = ETrue;

                CSensrvPluginProxy* proxy = AddProxy((*aImplementationInfos)[i]->ImplementationUid());

                if (proxy)

                    {

                    CImplementationInformation* implInfo = (*aImplementationInfos)[i];

                    err = proxy->InitializeChannelData( *implInfo );

                    if ( err != KErrNone )

                        {