/*
* 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 UpnpAiwCopyToExternalService
*
*/


#include <AiwCommon.hrh>
#include <AiwMenu.h>
#include <aknnotewrappers.h>
#include <upnpaiwmenuresources.rsg>
#include "upnpaiwengine.h"
#include "upnpaiwcopytoexternalservice.h"

_LIT( KComponentLogfile, "upnpaiwprovider.log" );
#include "upnplog.h"

// CONSTANTS
_LIT( KResFileName, "\\resource\\upnpaiwmenuresources.rsc" );

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::NewL
// NewL.
// --------------------------------------------------------------------------
CUPnPAiwCopyToExternalService* CUPnPAiwCopyToExternalService::NewL()
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::NewL" );

    CUPnPAiwCopyToExternalService* self = 
                    new (ELeave) CUPnPAiwCopyToExternalService;
    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::CUPnPAiwMoveToExternalService
// Constructor.
// --------------------------------------------------------------------------
CUPnPAiwCopyToExternalService::CUPnPAiwCopyToExternalService()
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
CUPnPAiwCopyToExternalService" );
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::~CUPnPAiwCopyToExternalService
// Destructor.
// --------------------------------------------------------------------------
CUPnPAiwCopyToExternalService::~CUPnPAiwCopyToExternalService()
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
~CUPnPAiwCopyToExternalService" );

    // Empty the file name array and close it
    EmptyFileNameArray();
    iFileNames.Close();

    // Delete the playlist name (if not yet deleted)
    delete iPlaylistName;

    // Release the engine instance
    if( iEngine )
        {
        CUPnPAiwEngine::ReleaseInstance();
        iEngine = NULL;
        }
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::ConstructL
// Second phase constructor.
// --------------------------------------------------------------------------
void CUPnPAiwCopyToExternalService::ConstructL()
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
ConstructL" );

    // Create the engine and register as an observer for call backs
    iEngine = CUPnPAiwEngine::NewL();
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::InitializeMenuPaneL
// AIW Framework's method for initialising the menu
// --------------------------------------------------------------------------
void CUPnPAiwCopyToExternalService::InitializeMenuPaneL( 
                CAiwMenuPane& aMenuPane,
                TInt aIndex,
                TInt /*aCascadeId*/,
                const CAiwGenericParamList& /*aInParamList*/ )
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
InitializeMenuPaneL" );

    // Update the drive letter to the path of the resource file name
    TUPnPEngineState engineState = iEngine->EngineState();
    if( engineState == EUPnPEngineNotConnected ||
        engineState == EUPnPEngineConnectionLost )
        {

        TFileName resFile( KResFileName );
        TFileName dllName;
        Dll::FileName( dllName );
        TBuf<2> drive = dllName.Left(2); // Drive letter followed by ':' 
        resFile.Insert( 0, drive );
    
        // Add the play menu item to the menu pane
        aMenuPane.AddMenuItemsL( resFile,
                                 R_AIW_COPY_TO_EXTERNAL_MENU,
                                 KAiwCmdUPnPCopy,
                                 aIndex );
        }
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::HandleMenuCmdL
// AIW Framework's method for handling menu commands
// --------------------------------------------------------------------------
void CUPnPAiwCopyToExternalService::HandleMenuCmdL( 
                TInt aMenuCmdId,
                const CAiwGenericParamList& aInParamList,
                CAiwGenericParamList& aOutParamList,
                TUint /*aCmdOptions*/,
                const MAiwNotifyCallback* /*aCallback*/ )
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
HandleMenuCmdL" );

    // Empty the file name array
    EmptyFileNameArray();

    // The playlist name (if we are doing a playlist copy)
    delete iPlaylistName;
    iPlaylistName = NULL;

    // Get the file name parameters
    if( aInParamList.Count() > 0 )
        {
        for( TInt index = 0; index < aInParamList.Count(); index++ )
            {
            // Get the filenames
            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 );
                }
            // Get the playlist name if it is not set already (only the first
            // playlist name will be used)
            if( aInParamList[index].SemanticId() == EGenericParamAlbumName &&
                !iPlaylistName )
                {
                iPlaylistName = HBufC::NewL( 
                        aInParamList[index].Value().AsDes().Length() );
                iPlaylistName->Des().Append( 
                        aInParamList[index].Value().AsDes() );
                }
            }
        }

    if( aMenuCmdId == KAiwCmdUPnPCopy )
        {
        if( iEngine )
            {
            if( iFileNames.Count()>0 )
                {
                // Do the copy
                TInt returnValue = KErrArgument;
                if( iPlaylistName == NULL )
                    {
                    // Normal copy
                    TRAP( returnValue,
                          iEngine->CopyToExternalL( iFileNames ) );
                    }
                else
                    {
                    // Playlist copy
                    TRAP( returnValue,
                          iEngine->CopyPlaylistToExternalL(
                                                    *iPlaylistName,
                                                    iFileNames ) );
                    }

                // Do some error translation regarding DRM protected files
                if ( returnValue == KErrNotSupported ||
                    returnValue == KErrPermissionDenied )
                    {
                    returnValue = KErrAccessDenied;
                    }

                // Add the return value on the out param list
                TAiwGenericParam statusParameter( 
                            EGenericParamError, 
                            returnValue );
                aOutParamList.AppendL( statusParameter );

                // Add the files that FAILED to copy to out param list.
                // finally, reset the array.
                for( TInt index=0; index<iFileNames.Count(); index++ )
                    {
                    if( iFileNames[index] )
                        {
                        // Create TAIWGenericParam for the filename
                        TFileName fileName( *iFileNames[index] );
                        TAiwGenericParam fileParameter( 
                                        EGenericParamFile, 
                                        fileName );

                        // Append the file filename param on the out list
                        aOutParamList.AppendL( fileParameter );
                        }
                    }
                iFileNames.ResetAndDestroy();

                }
            else
                {
                __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService, \
no files!" );
                }
            }
        else
            {
            __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService, \
engine is dead!" );
            }
        }

    // Clean up
    delete iPlaylistName;
    iPlaylistName = NULL;
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::EmptyFileNameArray
// Empties the file name array (data member variable).
// --------------------------------------------------------------------------
void CUPnPAiwCopyToExternalService::EmptyFileNameArray()
    {
    // 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();
    }

// --------------------------------------------------------------------------
// CUPnPAiwCopyToExternalService::ConnectionLostL
// Indicates that the connection with the target UPnP device has
// been lost.
// --------------------------------------------------------------------------
void CUPnPAiwCopyToExternalService::ConnectionLostL()
    {
    __LOG( "[UpnpAiwProvider]\t CUPnPAiwCopyToExternalService::\
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( KAiwCmdUPnPCopy,
                                eventCode,
                                *emptyParamlist,
                                *emptyParamlist );

        // Clean up
        CleanupStack::PopAndDestroy( emptyParamlist );
        emptyParamlist = NULL;
        }
    }

// End of file