/*

* 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 UpnpAiwPlayOnExternalBaseService

*

*/

#include <AiwMenu.h>

#include <AiwCommon.hrh>

#include <aknnotewrappers.h>

#include "upnpaiwengine.h"

#include "upnpaiwplayonexternalbaseservice.h"

#include "upnpdrmfilter.h"

_LIT( KComponentLogfile, "upnpaiwprovider.log" );

#include "upnplog.h"

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

// CUPnPAiwPlayOnExternalBaseService::NewL

// NewL.

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

CUPnPAiwPlayOnExternalBaseService* CUPnPAiwPlayOnExternalBaseService::NewL()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::NewL" );

    CUPnPAiwPlayOnExternalBaseService* self = 

                    new (ELeave) CUPnPAiwPlayOnExternalBaseService;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPAiwPlayOnExternalBaseService::CUPnPAiwPlayOnExternalBaseService

// Constructor.

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

CUPnPAiwPlayOnExternalBaseService::CUPnPAiwPlayOnExternalBaseService()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

CUPnPAiwPlayOnExternalBaseService" );

    }

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

// CUPnPAiwPlayOnExternalBaseService::~CUPnPAiwPlayOnExternalBaseService

// Destructor.

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

CUPnPAiwPlayOnExternalBaseService::~CUPnPAiwPlayOnExternalBaseService()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

~CUPnPAiwPlayOnExternalBaseService" );

    // Empty the file name array and close it

    EmptyFileNameArray();

    iFileNames.Close();

    // Delete the filename of the file that is played

    delete iFileName;

    iFileName = NULL;

    // Set the client call back reference to NULL

    iClient = NULL;

    // Release the engine instance

    if( iEngine )

        {

        CUPnPAiwEngine::ReleaseInstance();

        iEngine = NULL;

        }

    // Release the DRM filter AO

    delete iActiveDrmFilter;

    }

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

// CUPnPAiwPlayOnExternalBaseService::ConstructL

// Second phase constructor.

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

void CUPnPAiwPlayOnExternalBaseService::ConstructL()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

ConstructL" );

    // Create the engine and register as an observer for call backs

    iEngine = CUPnPAiwEngine::NewL();

    }

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

// CUPnPAiwPlayOnExternalBaseService::HandleServiceCmdL

// AIW Framework's method for handling service commands

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

void CUPnPAiwPlayOnExternalBaseService::HandleServiceCmdL( 

                                const TInt& aCmdId,

                                const CAiwGenericParamList& aInParamList,

                                CAiwGenericParamList& aOutParamList,

                                TUint /*aCmdOptions*/,

                                const MAiwNotifyCallback* aCallback )

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

HandleServiceCmdL" );

    // Cast the aCallback reference to non-const and store the reference

    iClient = const_cast<MAiwNotifyCallback*>(aCallback);

    // Empty the file name array

    EmptyFileNameArray();

    // Get the file name parameters

    if( aInParamList.Count() > 0 )

        {

        for( TInt index = 0; index < aInParamList.Count(); index++ )

            {

            if ( aInParamList[index].SemanticId() == EGenericParamFile )

                {

                // Store the file name in the array

                HBufC* fileName = HBufC::NewLC(

                    aInParamList[index].Value().AsDes().Length() );

                fileName->Des().Append(

                    aInParamList[index].Value().AsDes() );

                iFileNames.AppendL( fileName );

                CleanupStack::Pop( fileName );

                }

            }

        }

    // Process the command only if the command ID matches

    if( aCmdId == KAiwCmdUPnPPlay )

        {

        if( iEngine )

            {

            if( iFileNames.Count() == 1 )

                {

                // Filter out the DRM protected files

                RPointerArray<TDesC16> drmFiles;

                iActiveDrmFilter = CUpnpDrmFilter::NewL( iFileNames,

                            drmFiles );

                iActiveDrmFilter->FilterDrmL();

                TInt returnValue = KErrArgument;

                if( iFileNames.Count() == 1 )

                    {

                    // Delete and reallocate the filename of the file that is 

                    // going to be played

                    delete iFileName; iFileName = NULL;

                    iFileName = iFileNames[0]->AllocL();

                    // Register to observe the Engine call backs and then call

                    // Play on UPnP AIW Engine

                    iEngine->SetEngineObserver( this );

                    TRAP( returnValue, iEngine->PlayL( *iFileNames[0] ) );

                    }

                // If there were DRM protected files, return code is

                // KErrAccessDenied

                if( drmFiles.Count() > 0 )

                    {

                    returnValue = KErrAccessDenied;

                    }

                // Add the return value on the out param list

                TAiwGenericParam statusParameter( 

                                    EGenericParamError, 

                                    returnValue );

                aOutParamList.AppendL( statusParameter );

                // Add the drm protected files into the outparameter list

                for( TInt index=0; index<drmFiles.Count(); index++ )

                    {

                    if( drmFiles[index] )

                        {

                        // Create TAIWGenericParam for the filename

                        TFileName fileName( *drmFiles[index] );

                        TAiwGenericParam fileParameter( 

                                            EGenericParamFile, 

                                            fileName );

                        // Append the file filename param on the out list

                        aOutParamList.AppendL( fileParameter );

                        // Clean up

                        // Delete the file name item from the array

                        delete drmFiles[index];

                        drmFiles[index] = NULL;

                        }

                    }

                // Clean up the drm files array

                drmFiles.Reset();

                drmFiles.Close();

                // In case of play, the file item is not removed from the 

                // list if the play operation fails, so in this case the list

                // can be just emptied, no need to append the items on

                // the outparam list.

                EmptyFileNameArray();

                delete iActiveDrmFilter;

                iActiveDrmFilter = NULL;

                }

            else

                {

                __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService, \

invalid number of files!" );

                }

            }

        else

            {

            __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService, \

engine is dead!" );

            }

        }

    }

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

// CUPnPAiwPlayOnExternalBaseService::EmptyFileNameArray

// Empties the file name array (data member variable).

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

void CUPnPAiwPlayOnExternalBaseService::EmptyFileNameArray()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

HandleServiceCmdL" );

    // delete the list of file names and close the file name array

    for( TInt index=0; index<iFileNames.Count(); index++ )

        {

        delete iFileNames[index];

        iFileNames[index] = NULL;

        }

    iFileNames.Reset();

    }

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

// CUPnPAiwPlayOnExternalBaseService::PlayCompleteL

// Indicates that the play operation is complete.

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

void CUPnPAiwPlayOnExternalBaseService::PlayCompleteL( TInt aStatus )

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

PlayCompleteL" );

    // If there is a client that has registered as an observer

    if( iClient )

        {

        if( iFileName )

            {

            // Create parameter lists

            CAiwGenericParamList* eventParamList =

                                    CAiwGenericParamList::NewLC();

            CAiwGenericParamList* inParamList = 

                                    CAiwGenericParamList::NewLC();

            // Create TAIWGenericParam for the filename

            TFileName fileName( *iFileName );

            TAiwGenericParam fileParameter( EGenericParamFile, fileName );

            // Append the file filename param on the out list

            eventParamList->AppendL( fileParameter );

            // Convert the error code into AIW event code

            TInt eventCode;

            if( aStatus == KErrNone )

                {

                eventCode = KAiwEventCompleted;

                }

            else

                {

                eventCode = KAiwEventError;

                }

            // Make the call back

            iClient->HandleNotifyL( KAiwCmdUPnPPlay,

                                    eventCode,

                                    *eventParamList,

                                    *inParamList );

            // Clean up

            CleanupStack::PopAndDestroy( inParamList );

            inParamList = NULL;

            CleanupStack::PopAndDestroy( eventParamList );

            eventParamList = NULL;

            delete iFileName;

            iFileName = NULL;

            }

        }

    }

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

// CUPnPAiwPlayOnExternalBaseService::ConnectionLostL

// Indicates that the connection with the target UPnP device has 

// been lost.

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

void CUPnPAiwPlayOnExternalBaseService::ConnectionLostL()

    {

    __LOG( "[UpnpAiwProvider]\t CUPnPAiwPlayOnExternalBaseService::\

ConnectionLostL" );

    // If there is a client that has registered as an observer

    if( iClient )

        {

        // Create parameter lists

        CAiwGenericParamList* emptyParamlist = CAiwGenericParamList::NewLC();

        TInt eventCode = KAiwEventStopped;

        // Make the call back

        iClient->HandleNotifyL( KAiwCmdUPnPPlay,

                                eventCode,

                                *emptyParamlist,

                                *emptyParamlist );

        // Clean up

        CleanupStack::PopAndDestroy( emptyParamlist );

        emptyParamlist = NULL;

        if( iEngine )

            {

            iEngine->RemoveEngineObserver();

            }

        }

    }

// End of file