/*

* Copyright (c) 2005-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:  Implementation of the class CUPnPAiwEngine.

 *

*/

// INCLUDE FILES

// System

#include <bautils.h>

#include <AknWaitDialog.h>

#include <aknnotewrappers.h>

#include <StringLoader.h>

#include <utf.h>

// Upnp stack

#include <upnpitem.h>

// avcontroller api

#include "upnpavcontroller.h"

#include "upnpavcontrollerfactory.h"

#include "upnpavrenderingsession.h"

#include "upnpavsessionbase.h"

#include "upnpavdevice.h"

// avcontroller / avcontroller helper api

#include "upnpitemresolver.h"

#include "upnpitemresolverfactory.h"

#include "upnpitemutility.h"

#include "upnpresourceselector.h"

// upnpframework internal api's

#include "upnpfiletransferengine.h"     // Upnp Fw / UpnpFileTransferEngine

#include "upnpcommonutils.h"            // Upnp Fw / UpnpUtilities

// aiw engine internal

#include <upnpaiwengineresources.rsg>   // Upnp Fw / UpnpAiwEngine

#include "upnpaiwengine.h"                // Upnp Fw / UpnpAiwEngine

#include "upnpaiwtimer.h"               // Upnp Fw / UpnpAiwEngine

// logging

_LIT( KComponentLogfile, "upnpaiwengine.log" );

#include "upnplog.h"

const TInt KSlash = 92;

const TInt KDot = 46;

// CONSTANTS

_LIT( KResFileName, "\\resource\\upnpaiwengineresources.rsc" );

const TInt KAiwTimerIntervalInSeconds = 1;

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

// CUPnPAiwEngine::NewL

// NewL.

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

//

EXPORT_C CUPnPAiwEngine* CUPnPAiwEngine::NewL()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::NewL" );

    CUPnPAiwEngine* self = NULL;

    // If this is the first time we are getting the instance of this

    // singleton class, create the instance and store it into the

    // Thread Local Storage

    if( !Dll::Tls() )

        {

        self = new (ELeave) CUPnPAiwEngine;

        CleanupStack::PushL( self );

        self->ConstructL();

        CleanupStack::Pop( self );

        TInt err = Dll::SetTls( static_cast<TAny*>( self ) );

        if( err != KErrNone )

            {

            delete self;

            self = NULL;

            }

        else

            {

            // Initialise the user counter to zero

            self->InitialiseUserCounter();

            }

        }

    else

        {

        self = static_cast<CUPnPAiwEngine*>( Dll::Tls() );

        }

    // Increase number of users by one

    self->IncreaseUserCounter();

    return self;

    }

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

// CUPnPAiwEngine::ReleaseInstance

// Releases the instance.

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

//

EXPORT_C void CUPnPAiwEngine::ReleaseInstance()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::ReleaseInstance" );

    CUPnPAiwEngine* instance = NULL;

    // Get the instance from the TLS if there is an instance

    if( Dll::Tls() )

        {

        instance = static_cast<CUPnPAiwEngine*>( Dll::Tls() );

        }

    // If there still were an instance in the TLS

    if( instance )

        {

        // Decrease the number of instance

        instance->DecreaseUserCounter();

        // If the instance count is now 0, empty the TLS

        if( instance->UserCounter() <= 0 )

            {

            // Empty the TLS

            TInt err = Dll::SetTls( NULL );

            if( err )

                {

                // ignore

                }

            // Delete the instance

            delete instance;

            instance = NULL;

            }

        }

    }

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

// Constructor

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

//

CUPnPAiwEngine::CUPnPAiwEngine()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::CUPnPAiwEngine" );

    iRenderingSessionInUse = EFalse;

    iVideoPlay = EFalse;

    iFileName = NULL;

    iVideoPlayCancel = EFalse;

    iVideoPlayWait = EFalse;

    }

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

// Destructor

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

//

CUPnPAiwEngine::~CUPnPAiwEngine()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::~CUPnPAiwEngine" );

    // Delete resolvers

    // Delete for resolvers is done using temporary variables so that we can

    // first nullify the members and then delete the actual objects.

    // This is because local resolver deletion uses active scheduler loops

    // and therefore other asynchronous events may orrur. So we may end

    // up here in Cleanup again, during the resolver is being deleted.

    // if deletion is done the conventional way, the objects get deleted

    // twice, which is not what we want. :-)

    MUPnPItemResolver* tempResolver = iResolver;

    iResolver = NULL;

    delete tempResolver;

    StopTimer();

    // If wait note is shown, finish it

    if (iWaitNoteDialog)

        {

        TRAP_IGNORE( iWaitNoteDialog->ProcessFinishedL() );

        }

    if (iRenderingSession && iAVController)

        {

        TRAP_IGNORE( iAVController->StopRenderingSession(

                        *iRenderingSession ) );

        iRenderingSession = NULL;

        }

    delete iCommonUI;

    // Delete the UPnP AV Controller

    delete iAVController;

    delete iFileName;

    // Un-load resource file

    if (iResFileOffset)

        {

        CEikonEnv::Static()->DeleteResourceFile(iResFileOffset);

        iResFileOffset = 0;

        }

    }

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

// CUPnPAiwEngine::ConstructL

// Second phase constructor

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

//

void CUPnPAiwEngine::ConstructL()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::ConstructL" );

    iCoeEnv = CEikonEnv::Static();

    RFs& fileSession = iCoeEnv->FsSession();

    // Load resource file

    TFileName rscFileName(KResFileName);

    TFileName dllName;

    Dll::FileName(dllName);

    TBuf<2> drive = dllName.Left(2); // Drive letter followed by ':' 

    rscFileName.Insert( 0, drive);

    // Get the exact filename of the resource file

    BaflUtils::NearestLanguageFile(fileSession, rscFileName);

    // Check if the resource file exists or not

    if ( !BaflUtils::FileExists(fileSession, rscFileName) )

        {

        __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, resource file does not \

exist!" );

        User::Leave(KErrNotFound);

        }

    if (iCoeEnv)

        {

        // Read the resource file offset

        iResFileOffset = iCoeEnv->AddResourceFileL(rscFileName);

        }

    // Set initial state of the connection to the UPnPAVController

    iCommonUI = CUPnPCommonUI::NewL();

    iAVController = NULL;

    iRenderingSession = NULL;

    iEngineState = EUPnPEngineNotConnected;

    }

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

// CUPnPAiwEngine::SetEngineObserver

// Sets the observer instance.

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

//

EXPORT_C void CUPnPAiwEngine::SetEngineObserver(

        MUPnPAiwEngineObserver* aObserver )

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::SetEngineObserver" );

    if( aObserver )

        {

        iObserver = aObserver;

        }

    }

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

// CUPnPAiwEngine::RemoveEngineObserver

// Sets the observer instance.

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

//

EXPORT_C void CUPnPAiwEngine::RemoveEngineObserver()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::RemoveEngineObserver" );

    iObserver = NULL;

    }

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

// CUPnPAiwEngine::EngineState

// Gets the state of the UPnP AIW Engine.

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

//

EXPORT_C TUPnPEngineState CUPnPAiwEngine::EngineState()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::EngineState" );

    return iEngineState;

    }

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

// CUPnPAiwEngine::OpenExternalMediaL

// Opens the External media UI.

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

//

EXPORT_C void CUPnPAiwEngine::OpenExternalMediaL()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::OpenExternalMediaL" );

    TInt status = KErrNone;

    if( !iAVController &&

            iEngineState == EUPnPEngineNotConnected )

        {

        TRAP( status,

                iAVController =

                UPnPAVControllerFactory::NewUPnPAVControllerL() );

        if( status == KErrNone &&

                iAVController )

            {

            // Update engine state

            iEngineState = EUPnPEngineBrowsingHomeNetwork;

            TInt leaveCode = KErrNone;

            TRAP( leaveCode,

                    status = iCommonUI->ExecuteDeviceDialogL( *iAVController ) );

            // Handle status and leave codes

            if( leaveCode != KErrNone &&

                    status == KErrNone )

                {

                status = leaveCode;

                }

            // Clean up and return the engine state

            delete iAVController;

            iAVController = NULL;

            iEngineState = EUPnPEngineNotConnected;

            }

        else // If the instantiation of UpnpAvController fails

            {

            TRAP_IGNORE( ShowConnectionErrorL() );

            status = KErrCouldNotConnect;

            }

        }

    else // If the UpnpAvController is already instantiated

        {

        status = KErrInUse;

        }

    if( status != KErrNone )

        {

        User::Leave( status );

        }

    }

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

// CUPnPAiwEngine::EnableExternalL

// Enables the showing of local media files on a remote renderer device.

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

//

EXPORT_C void CUPnPAiwEngine::EnableExternalL()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::EnableExternalL" );

    TInt status = KErrNone;

    if( !iAVController &&

            iEngineState == EUPnPEngineNotConnected )

        {

        TRAP( status,

                iAVController =

                UPnPAVControllerFactory::NewUPnPAVControllerL() );

        if( status == KErrNone &&

                iAVController )

            {

            iAVController->SetDeviceObserver( *this );

            TRAP( status, StartRenderingSessionL(

                            EUPnPAiwEngineTargetDeviceWithImageSupport ) );

            // If the rendering session was created successfully

            if( status == KErrNone &&

                    iRenderingSession )

                {

                // Start local file sharing

                TRAP( status,

                        StartLocalFileSharingL( iRenderingSession ) );

                    {

                    // If the file sharing failed to start, undo the enable

                    // external by calling disable external.

                    if( status != KErrNone )

                        {

                        DisableExternal();

                        }

                    }

                }

            else

                {

                delete iAVController;

                iAVController = NULL;

                iEngineState = EUPnPEngineNotConnected;

                }

            }

        else // If the instantiation of UpnpAvController fails

            {

            TRAP_IGNORE( ShowConnectionErrorL() );

            status = KErrCouldNotConnect;

            }

        }

    else

        {

        status = KErrInUse;

        }

    if( status != KErrNone )

        {

        User::Leave( status );

        }

    }

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

// CUPnPAiwEngine::DisableExternal

// Disables the showing of local media files on a remote renderer device.

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

//

EXPORT_C void CUPnPAiwEngine::DisableExternal()

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::DisableExternal" );

    if( iAVController )

        {

        if( iRenderingSession )

            {

            // If STOP action is required, use the timer to delay the

            // destruction (give some time for AvController to send the STOP

            // action message)

            if( iEngineState == EUPnPEngineActive )

                {

                TRAP_IGNORE( iRenderingSession->StopL() );

                StartTimer();

                }

            else

                {

                // Stop local file sharing

                TRAP_IGNORE( iRenderingSession->ReleaseLocalMSServicesL() );

                // Stop the rendering session

                TRAP_IGNORE( iAVController->StopRenderingSession(

                                *iRenderingSession ) );

                iRenderingSession = NULL;

                }

            }

        // Delete the UPnP AV Controller

        delete iAVController;

        iAVController = NULL;

        }

    // Update engine state

    iRenderingSessionInUse = EFalse;

    iEngineState = EUPnPEngineNotConnected;

    }

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

// CUPnPAiwEngine::PlayL

// Plays (sends for rendering) local media file using the selected

// UPnP Media renderer.

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

//

EXPORT_C void CUPnPAiwEngine::PlayL( const TDesC& aFileName )

    {

    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::PlayL" );

    TInt status = KErrNone;

    if( aFileName != KNullDesC )

        {

        if( iAVController &&

                iRenderingSession &&

                ( iEngineState == EUPnPEngineConnected ||

                        iEngineState == EUPnPEngineActive ) )

            {

            // Check the file type

            TUPnPItemType fileType = ETypeOther;

            TRAPD( mimeError,

                    fileType = UPnPCommonUtils::ResolveFileTypeL(

                            aFileName ) );

            if( mimeError == KErrNone )

                {

                if( fileType == ETypeAudio )

                    {

                    status = KErrNotSupported;

                    if( iObserver )

                        {

                        iObserver->PlayCompleteL( status );

                        }

                    __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

audio files not supported!" );

                    }

                else if ( fileType == ETypeVideo )

                    {

                    if( iRenderingSessionInUse )

                        {

                        //if the previous operation not finished

                        delete iFileName; iFileName = NULL;

                        iFileName = aFileName.AllocL();

                        iVideoPlayWait = ETrue;

                        }

                    else

                        {

                        TRAP( status, StartVideoPlayL( aFileName ) );

                        }

                    }

                else if ( fileType == ETypeImage )

                    {

                    if( !iVideoPlay ) //if no video is being played

                        {

                        if( iRenderingSessionInUse )

                            {

                            //if the previous operation not finished

                            iVideoPlayWait = EFalse;

                            __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

iRenderingSessionInUse: ETrue" );

                            delete iFileName;

                            iFileName = NULL;

                            iFileName = aFileName.AllocL();

                            }

                        else