/*
* Copyright (c) 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 for the CUpnpPlaylistHandler class
*
*/


// INCLUDES
#include <bautils.h>                            // CDesCArray

#include "upnpplaylistservices.h"               // CUPnPPlaylistServices
#include <pathinfo.h>                           // PathInfo
#include "upnpplaylisthandler.h"                // CUpnpPlaylistHandler
#include <upnpitem.h>                           // CUpnpItem
#include "upnpsettingsengine.h"                 // CUpnpSettingsEngine

_LIT( KComponentLogfile, "filetransferengine.txt");
#include "upnplog.h"

// CONSTANTS
const TInt KItemArrayGranularity =  16;

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::NewL
// NewL.
// --------------------------------------------------------------------------
//
CUpnpPlaylistHandler* CUpnpPlaylistHandler::NewL()
    {
    __LOG( "[UpnpPlaylistHandler] CUpnpPlaylistHandler: NewL" );

    CUpnpPlaylistHandler* self = NULL;
    self = new (ELeave) CUpnpPlaylistHandler;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// Constuctor
// --------------------------------------------------------------------------
//
CUpnpPlaylistHandler::CUpnpPlaylistHandler()
    {
    __LOG( "[UpnpPlaylistHandler] Constructor" );
    }

// --------------------------------------------------------------------------
// Destructor
// --------------------------------------------------------------------------
//
CUpnpPlaylistHandler::~CUpnpPlaylistHandler()
    {
    __LOG( "[UpnpPlaylistHandler] Destructor" );

    // If there are items on the playlists, create the playlists now before
    // deleting the content
    
    delete iPlaylistServices;
    iPlaylistServices = NULL;
    
    if( iPlaylistName )
        {
        if( iFilesForAudioPlaylist )
            {
            if( iFilesForAudioPlaylist->Count() > 0 )
                {
                TRAP_IGNORE( CreateMusicPlaylistL() );
                }
            }
        if( iFilesForVideoAlbum.Count() > 0 )
            {
            TRAP_IGNORE( CreateVideoAlbumL() );
            }
        if( iFilesForImageAlbum.Count() > 0 )
            {
            TRAP_IGNORE( CreateImageAlbumL() );
            }
        }

    // Empty and destroy the playlist arrays
    Reset();
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::ConstructL
// Second phase constructor
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::ConstructL()
    {
    __LOG( "[UpnpPlaylistHandler] ConstructL" );
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::Reset
// Empties the playlists.
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::Reset()
    {
    __LOG( "[UpnpPlaylistHandler] Reset" );

    // Delete the playlist name
    delete iPlaylistName;
    iPlaylistName = NULL;

    // Delete the audio playlist item arrays
    delete iFilesForAudioPlaylist;
    iFilesForAudioPlaylist = NULL;

    // Delete the video album item array
    iFilesForVideoAlbum.ResetAndDestroy();
    iFilesForVideoAlbum.Close();

    // Delete the image album item array
    iFilesForImageAlbum.ResetAndDestroy();
    iFilesForImageAlbum.Close();    
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::SetPlaylistNameL
// Sets the name for the playlist
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::SetPlaylistNameL( const TDesC& aPlaylistName )
    {
    __LOG( "[UpnpPlaylistHandler] SetPlaylistNameL" );
    
    // Check parameter
    if( aPlaylistName == KNullDesC )
        {
        User::Leave( KErrArgument );
        }

    // If a playlist name is already provided, delete it and replace with
    // this new one
    delete iPlaylistName; iPlaylistName = NULL;
    iPlaylistName = aPlaylistName.AllocL();
    }    
    
// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::AddAudioItemL
// Adds an audio item to the playlist (playlist will not be generated yet, it
// has to be created by calling a separate method).
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::AddAudioItemL( const TDesC& aFilePath )
    {
    __LOG( "[UpnpPlaylistHandler] AddAudioItemL" );
    
    // Check parameters
    if( aFilePath == KNullDesC )
        {
        User::Leave( KErrArgument );
        }

    // If the item arrays for audio item are not yet created, create them now
    if( !iFilesForAudioPlaylist )
        {
        iFilesForAudioPlaylist = 
                new (ELeave) CDesCArrayFlat( KItemArrayGranularity );
        }

    // Add the item information in the arrays
    iFilesForAudioPlaylist->AppendL( aFilePath );
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::AddImageItemL
// Adds an image item to the playlist (playlist will not be generated yet, it
// has to be created by calling a separate method).
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::AddImageItemL( const TDesC& aFilePath )
    {
    __LOG( "[UpnpPlaylistHandler] AddImageItemL" );
    
    // Check parameters
    if( aFilePath == KNullDesC )
        {
        User::Leave( KErrArgument );
        }

    // Add the item information in the array
    iFilesForImageAlbum.AppendL( aFilePath.AllocL() );
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::AddVideoItemL
// Adds a video item to the playlist (playlist will not be generated yet, it
// has to be created by calling a separate method).
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::AddVideoItemL( const TDesC& aFilePath )
    {
    __LOG( "[UpnpPlaylistHandler] AddVideoItemL" );

    // Check parameters
    if( aFilePath == KNullDesC )
        {
        User::Leave( KErrArgument );
        }

    // Add the item information in the array
    iFilesForVideoAlbum.AppendL( aFilePath.AllocL() );
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::AudioItemCount
// Returns the number of items in the audio item array.
// --------------------------------------------------------------------------
//
TInt CUpnpPlaylistHandler::AudioItemCount()
    {
    __LOG( "[UpnpPlaylistHandler] AudioItemCount" );
    
    TInt returnValue = 0;
    if( iFilesForAudioPlaylist )
        {
        returnValue = iFilesForAudioPlaylist->Count();
        }

    return returnValue;
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::ImageItemCount
// Returns the number of items in the image item array.
// --------------------------------------------------------------------------
//
TInt CUpnpPlaylistHandler::ImageItemCount()
    {
    __LOG( "[UpnpPlaylistHandler] ImageItemCount" );

    return iFilesForImageAlbum.Count();
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::VideoItemCount
// Returns the number of items in the video item array.
// --------------------------------------------------------------------------
//
TInt CUpnpPlaylistHandler::VideoItemCount()
    {
    __LOG( "[UpnpPlaylistHandler] VideoItemCount" );

    return iFilesForVideoAlbum.Count();
   }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::CreateMusicPlaylistL
// Creates a MPX playlist (if there are music items added).
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::CreateMusicPlaylistL()
    {
    __LOG( "[UpnpPlaylistHandler] CreateMusicPlaylistL" );

    // Create playlist only if required data exists
    if( iPlaylistName &&
        iFilesForAudioPlaylist &&
        iFilesForAudioPlaylist->Count() > 0 )
        {
        TBool location = PlaylistFileLocation();
        if( location )
            {
            if ( !iPlaylistServices )
                {
                iPlaylistServices = CUPnPPlaylistServices::NewL();
                }

            TRAPD( createPlaylistError,
                  iPlaylistServices->CreatePlaylistL(
                            *iPlaylistName,
                            *iFilesForAudioPlaylist,
                            NULL ) );
            if( createPlaylistError != KErrNone )
                {
                __LOG( "[UpnpPlaylistHandler] Failed to create a \
playlist!" );
                }
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::CreateImageAlbumL
// Creates an image album (if there are image items added).
// Not in use in upnp 2.1
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::CreateImageAlbumL()
    {
    __LOG( "[UpnpPlaylistHandler] CreateImageAlbumL" );

    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::CreateVideoAlbumL
// Creates a video album (if there are video items added).
// Not in use in upnp 2.1
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::CreateVideoAlbumL()
    {
    __LOG( "[UpnpPlaylistHandler] CreateVideoAlbumL" );
     
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::PlaylistFileLocation
// Checks that Playlist location is valid.
// --------------------------------------------------------------------------
//
TBool CUpnpPlaylistHandler::PlaylistFileLocation()
    {
    __LOG( "[UpnpPlaylistHandler] PlaylistFileLocation" );

    TBool returnValue = EFalse;
    TInt error = KErrGeneral; 
    TParse parse;
    TDriveNumber defauldrive;
    
    // Default download drive
    TRAP( error,
        CUPnPSettingsEngine* engine = CUPnPSettingsEngine::NewLC();
        engine->GetCopyLocationDriveL( defauldrive );
        CleanupStack::PopAndDestroy( engine );
        );
       
    // Playlist location
    if( error == KErrNone )
        {   
        // There are audio files on the playlist
        if( iFilesForAudioPlaylist &&
            iFilesForAudioPlaylist->Count() > 0 )
            {
            error = parse.Set( iFilesForAudioPlaylist->MdcaPoint(0), 
                                NULL, NULL );
            }

        // There are image files on the playlist
        else if( iFilesForImageAlbum.Count() > 0 )
            {    
            error = parse.Set( *iFilesForImageAlbum[0], NULL, NULL );
            }

        // There are video files on the playlist
        else if( iFilesForVideoAlbum.Count() > 0 )
            {
            error = parse.Set( *iFilesForVideoAlbum[0], NULL, NULL );
            }
        else
            {
            // error code is already set
            }
        } 
        
    // Playlist must be located to default download drive    
    if( error == KErrNone )
        {
        TPtrC drive = parse.Drive();
        TDriveUnit driveUnit = TDriveUnit( drive );
        TDriveNumber playlistdrive = (TDriveNumber)((TInt)driveUnit);
 
        if( playlistdrive == defauldrive )
            {
            returnValue = ETrue;
            }
        }   
        
    __LOG1( "[UpnpPlaylistHandler] PlaylistFileLocation %d end", returnValue );  
    
    return returnValue;
    }

// --------------------------------------------------------------------------
// CUpnpPlaylistHandler::NotifyNewAudioFileL
// Notifies MPX of a new audio file.
// --------------------------------------------------------------------------
//
void CUpnpPlaylistHandler::NotifyNewAudioFileL(
                                            const TDesC& aFilePath,
                                            const CUpnpItem& aMetadata )
    {
    __LOG( "[UpnpPlaylistHandler] NotifyNewAudioFileL" );

    if( aFilePath == KNullDesC )
        {
        User::Leave( KErrArgument );
        }

    if ( !iPlaylistServices )
        {
        iPlaylistServices = CUPnPPlaylistServices::NewL();
        }

    TRAPD( notifyError,
        iPlaylistServices->CreateTrackL( aFilePath, aMetadata ) );
    if ( notifyError != KErrNone )
        {
        __LOG( "[UpnpPlaylistHandler] Failed to notify audio track" );
        }
    }

// End of file