/*
* Copyright (c) 2006-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:  Utility class for CDunServer
*
*/


#include <e32uid.h>
#include "DunServer.h"
#include "DunServerUtils.h"
#include "DunDebug.h"

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CDunServerUtils* CDunServerUtils::NewL( CDunServer& aParent )
    {
    CDunServerUtils* self = new (ELeave) CDunServerUtils( aParent );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CDunServerUtils::~CDunServerUtils()
    {
    FTRACE(FPrint(_L("CDunServerUtils::~CDunServerUtils()")));
    FTRACE(FPrint(_L("CDunServerUtils::~CDunServerUtils() complete")));
    }

// ---------------------------------------------------------------------------
// CDunServerUtils::CDunServerUtils
// ---------------------------------------------------------------------------
//
CDunServerUtils::CDunServerUtils( CDunServer& aParent ) :
    iParent( aParent ),
    iTransporter( aParent.iTransporter ),
    iCloseWait( aParent.iCloseWait ),
    iConnData( aParent.iConnData ),
    iPluginQueue( aParent.iPluginQueue ),
    iClosedQueue( aParent.iClosedQueue )
    {
    }

// ---------------------------------------------------------------------------
// CDunServerUtils::ConstructL
// ---------------------------------------------------------------------------
//
void CDunServerUtils::ConstructL()
    {
    FTRACE(FPrint( _L("CDunServerUtils::ConstructL()" ) ));
    FTRACE(FPrint( _L("CDunServerUtils::ConstructL() complete" ) ));
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Closes plugins with state marked as zombie
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::RemoveZombiePlugins()
    {
    FTRACE(FPrint(_L("CDunServerUtils::RemoveZombiePlugins()")));
    TInt i;
    TInt retVal = KErrNone;
    for ( i=iConnData.Count()-1; i>=0; i-- )
        {
        if ( iConnData[i].iPluginState == EDunStateZombie )
            {
            // Following closes and removes if remove ok
            FTRACE(FPrint(_L("CDunServerUtils::RemoveZombiePlugins() trying close at index %d"), i));
            TInt retTemp = TryClosePlugin( i, ETrue, EFalse, EFalse );
            if ( retTemp != KErrNone )
                {
                retVal = KErrGeneral;
                }
            }
        }
    FTRACE(FPrint(_L("CDunServerUtils::RemoveZombiePlugins() complete")));
    return retVal;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Loads local media module
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::CreateNewPlugin( TUid aPluginUid )
    {
    FTRACE(FPrint(_L("CDunServerUtils::CreateNewPlugin()")));
    // plugin not constructed, construct now
    TFileName pluginFile;
    switch ( aPluginUid.iUid )
        {
        case KDunBtPluginUidValue:
            pluginFile.Copy( KDunPluginBt );
            break;
        case KDunIrPluginUidValue:
            pluginFile.Copy( KDunPluginIrda );
            break;
        case KDunUsbPluginUidValue:
            pluginFile.Copy( KDunPluginUsb );
            break;
        default:
            FTRACE(FPrint(_L("CDunServerUtils::CreateNewPlugin() (not supported) complete")));
            return KErrNotSupported;
        }
    TDunConnectionData emptyConn;
    emptyConn.iLocalModulePtr = NULL;
    emptyConn.iLocalModuleUid = TUid::Null();
    emptyConn.iPluginState = EDunStateNone;
    TInt retTemp = iConnData.Append( emptyConn );
    if ( retTemp != KErrNone )
        {
        FTRACE(FPrint(_L("CDunServerUtils::CreateNewPlugin() (append failed!) complete")));
        return retTemp;
        }
    retTemp = ConstructLocalMediaModule( aPluginUid, pluginFile );
    if ( retTemp != KErrNone )
        {
        iConnData.Remove( iConnData.Count()-1 );
        FTRACE(FPrint(_L("CDunServerUtils::CreateNewPlugin() (ERROR) complete")));
        return retTemp;
        }
    FTRACE(FPrint(_L("CDunServerUtils::CreateNewPlugin() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Constructs local media module
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::ConstructLocalMediaModule( const TUid& aPluginUid,
                                                 const TPtrC& aDllName )
    {
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule()")));
    // Create a new library object
    if ( iConnData.Count() == 0 )
        {
        FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() (not ready) complete")));
        return KErrNotReady;
        }
    TInt index = iConnData.Count() - 1;
    iConnData[index].iLocalModuleUid = aPluginUid;
    iConnData[index].iPluginState = EDunStateTryLoad;
    // Load the DLL containing the plug-in
    TUidType uidType( KDynamicLibraryUid,
                      KDunLocalMediaPluginInterfaceUid,
                      aPluginUid );
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() loading")));
    TInt retTemp = iConnData[index].iModuleLibrary.Load( aDllName, uidType );
    if ( retTemp != KErrNone )
        {
        FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() (ERROR) complete")));
        return retTemp;
        }
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() plugin 0x%08X loaded"), aPluginUid.iUid));
    // Create the plugin object.
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() looking up")));
    TLibraryFunction factoryFunction = iConnData[index].iModuleLibrary.Lookup( 1 );
    if ( !factoryFunction )
        {
        iConnData[index].iModuleLibrary.Close();
        FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() (ERROR) complete")));
        return KErrNotFound;
        }
    MDunLocalMediaPlugin* localPlugin =
        reinterpret_cast<MDunLocalMediaPlugin*>( factoryFunction() );
    if ( !localPlugin )
        {
        iConnData[index].iModuleLibrary.Close();
        FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() (ERROR) complete")));
        return KErrGeneral;
        }
    iConnData[index].iLocalModulePtr = localPlugin;
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() constructing")));
    TRAPD( retTrap, localPlugin->ConstructL(&iParent, iTransporter) );
    if ( retTrap != KErrNone )
        {
        delete iConnData[index].iLocalModulePtr;
        iConnData[index].iLocalModulePtr = NULL;
        iConnData[index].iModuleLibrary.Close();
        FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() (ERROR) complete")));
        return retTrap;
        }
    iConnData[index].iPluginState = EDunStateLoaded;
    FTRACE(FPrint(_L("CDunServerUtils::ConstructLocalMediaModule() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Clears queued UIDs
// ---------------------------------------------------------------------------
//
TBool CDunServerUtils::ClearQueuedUIDs( TUid aPluginUid,
                                        TBool aClearClosed,
                                        TBool aClearQueued )
    {
    FTRACE(FPrint(_L("CDunServerUtils::ClearQueuedUIDs()")));
    TInt i;
    TBool cleared = EFalse;
    if ( aClearClosed )
        {
        for ( i=iClosedQueue.Count()-1; i>=0; i-- )
            {
            if ( iClosedQueue[i] == aPluginUid )
                {
                iClosedQueue.Remove( i );
                cleared = ETrue;
                FTRACE(FPrint(_L("CDunServerUtils::ClearQueuedUIDs() removed from closed queue at %d"), i));
                }
            }
        }
    if ( aClearQueued )
        {
        for ( i=iPluginQueue.Count()-1; i>=0; i-- )
            {
            if ( iPluginQueue[i] == aPluginUid )
                {
                iPluginQueue.Remove( i );
                cleared = ETrue;
                FTRACE(FPrint(_L("CDunServerUtils::ClearQueuedUIDs() removed from plugin queue at %d"), i));
                }
            }
        }
    FTRACE(FPrint(_L("CDunServerUtils::ClearQueuedUIDs() complete")));
    return cleared;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Tries to close loaded local media plugin
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::TryClosePlugin( TInt aIndex,
                                      TBool aDequeue,
                                      TBool aClientClose,
                                      TBool aSelfClose )
    {
    FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin()")));
    if ( aIndex < 0 ||
         aIndex >= iConnData.Count() )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() (not found) complete")));
        return KErrNotFound;
        }
    TInt retTemp = TryUninitialize( aIndex );
    if ( retTemp != KErrNone )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() (ERROR) complete")));
        return retTemp;
        }
    if ( !aSelfClose )
        {
        retTemp = DoClosePlugin( aIndex, aDequeue, aClientClose );
        FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() complete")));
        return retTemp;
        }
    retTemp = iCloseWait->AddPluginToClose( iConnData[aIndex].iLocalModulePtr );
    if ( retTemp != KErrNone )
        {
        iConnData[aIndex].iPluginState = EDunStateZombie;
        FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() state changed to %d"), EDunStateZombie));
        return retTemp;
        }
    retTemp = iCloseWait->IssueRequest();
    if ( retTemp != KErrNone )
        {
        iConnData[aIndex].iPluginState = EDunStateZombie;
        FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() state changed to %d"), EDunStateZombie));
        return retTemp;
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryClosePlugin() (waiting) complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Closes a plugin directly without uninitializing it
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::DoClosePlugin(
    TInt aIndex,
    TBool aDequeue,
    TBool aClientClose )
    {
    FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin()")));
    if ( aIndex < 0 ||
         aIndex >= iConnData.Count() )
        {
        FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin() (not found) complete")));
        return KErrNotFound;
        }
    TUid pluginUid = iConnData[aIndex].iLocalModuleUid;
    DoImmediatePluginClose( aIndex, aDequeue );
    if ( !aClientClose )
        {
        // Plugin was closed by something else than client
        // Enqueue it to closed queue
        TInt i;
        TInt count = iClosedQueue.Count();
        for ( i=0; i<count; i++ )
            {
            if ( iClosedQueue[i] == pluginUid )
                {
                FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin() (already exists) complete")));
                return KErrAlreadyExists;
                }
            }
        TInt retTemp = iClosedQueue.Append( pluginUid );
        if ( retTemp != KErrNone )
            {
            FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin() (append failed!) complete")));
            return retTemp;
            }
        FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin() appended to index %d"), iClosedQueue.Count()-1));
        }
    FTRACE(FPrint(_L("CDunServerUtils::DoClosePlugin() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Does immediate close of plugin
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::DoImmediatePluginClose( TInt aIndex, TBool aDequeue )
    {
    FTRACE(FPrint(_L("CDunServerUtils::DoImmediatePluginClose()")));
    if ( aIndex < 0 ||
         aIndex >= iConnData.Count() )
        {
        FTRACE(FPrint(_L("CDunServerUtils::DoImmediatePluginClose() (not found) complete")));
        return KErrNotFound;
        }
    delete iConnData[aIndex].iLocalModulePtr;
    iConnData[aIndex].iLocalModulePtr = NULL;
    if ( iConnData[aIndex].iModuleLibrary.Handle() != KNullHandle )
        {
        iConnData[aIndex].iModuleLibrary.Close();
        }
    iConnData.Remove( aIndex );
    // Now, the following check is needed to avoid recursion by:
    // ReopenQueuedPlugins()->OpenMediaByUid()->TryClosePlugin()->
    // DoImmediatePluginClose()->ReopenQueuedPlugins()
    if ( aDequeue )
        {
        iParent.ReopenQueuedPlugins();
        }
    // Ignore error(s); this function must only report it's own operation status
    FTRACE(FPrint(_L("CDunServerUtils::DoImmediatePluginClose() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Tries uninitialization and after that listening state switch on a plugin
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::TryInitializeToListening( TUid aPluginUid )
    {
    FTRACE(FPrint(_L("CDunServerUtils::TryInitializeToListening()")));
    TInt i;
    TInt count = iConnData.Count();
    for ( i=0; i<count; i++ )
        {
        if ( iConnData[i].iLocalModuleUid == aPluginUid )
            {
            break;
            }
        }
    if ( i >= count )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryInitializeToListening() (not found) complete")));
        return KErrNotFound;
        }
    TInt retTemp = TryUninitialize( i );
    if ( retTemp != KErrNone )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryInitializeToListening() (uninitialize error) complete")));
        return retTemp;
        }
    // Change from Uninitialized to Loaded because listening mode needs it
    // (plugin is already loaded anyway)
    iConnData[i].iPluginState = EDunStateLoaded;
    retTemp = TryListening( i );
    if ( retTemp != KErrNone )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryInitializeToListening() (listening error) complete")));
        return retTemp;
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryInitializeToListening() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Tries listening state switch on a plugin
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::TryListening( TInt aIndex )
    {
    FTRACE(FPrint(_L("CDunServerUtils::TryListening()")));
    if ( aIndex < 0 ||
         aIndex >= iConnData.Count() )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryListening() (not found) complete")));
        return KErrNotFound;
        }
    if ( iConnData[aIndex].iPluginState != EDunStateLoaded )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryListening() (not ready) complete")));
        return KErrNotReady;
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryListening() notifying server state change (%d)"), EDunStateTryListen));
    TInt retTemp =
        iConnData[aIndex].iLocalModulePtr->NotifyServerStateChange( EDunStateTryListen );
    if ( retTemp != KErrNone )
        {
        iConnData[aIndex].iPluginState = EDunStateZombie;
        FTRACE(FPrint(_L("CDunServerUtils::TryListening() state changed to %d"), EDunStateZombie));
        FTRACE(FPrint(_L("CDunServerUtils::TryListening() (ERROR) complete")));
        return retTemp;
        }
    // Plugin could have changed state, only change state if possible
    // This can happen if plugin has no real listening and switches directly
    // from listening mode to channeled mode
    if ( iConnData[aIndex].iPluginState == EDunStateTryListen )
        {
        iConnData[aIndex].iPluginState = EDunStateListening;
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryListening() state changed to %d"), EDunStateListening));
    FTRACE(FPrint(_L("CDunServerUtils::TryListening() complete")));
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MDunServerUtility.
// Tries uninitialization of a plugin
// ---------------------------------------------------------------------------
//
TInt CDunServerUtils::TryUninitialize( TInt aIndex )
    {
    FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize()")));
    if ( aIndex < 0 ||
         aIndex >= iConnData.Count() )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() (not found) complete")));
        return KErrNotFound;
        }
    if ( iConnData[aIndex].iPluginState == EDunStateUninitialized )
        {
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() (already uninitialized) complete")));
        return KErrNotReady;
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() notifying server state change (%d)"), EDunStateTryUninitialize));
    TInt retTemp =
        iConnData[aIndex].iLocalModulePtr->NotifyServerStateChange( EDunStateTryUninitialize );
    if ( retTemp != KErrNone )
        {
        iConnData[aIndex].iPluginState = EDunStateZombie;
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() state changed to %d"), EDunStateZombie));
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() (ERROR) complete")));
        return retTemp;
        }
    // Plugin state must be EDunStateLoaded after uninitialization
    if ( iConnData[aIndex].iPluginState == EDunStateLoaded )
        {
        iConnData[aIndex].iPluginState = EDunStateUninitialized;
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() state changed to %d"), EDunStateUninitialized));
        }
    else
        {
        // Should never come here
        iConnData[aIndex].iPluginState = EDunStateZombie;
        FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() state changed to %d"), EDunStateZombie));
        }
    FTRACE(FPrint(_L("CDunServerUtils::TryUninitialize() complete")));
    return KErrNone;
    }