/*

* Copyright (c) 2002-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 to get path related info for the media files

*/

// INCLUDE FILES

#include <bautils.h>    

#include <upnpstring.h>

#include <upnpdlnaprotocolinfo.h>

#include <pathinfo.h>

#include <CentralRepository.h>

#include "upnpmspathutility.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpcdutils.h"

#include "upnpdominterface.h"

// CONSTANTS

_LIT( KYearMonthDayFormat,        "%04d\\%02d\\%02d\\");

_LIT( KArtistFormat,              "%S\\");

_LIT( KAlbumFormat,               "%S\\");

_LIT( KBackSlash,                 "\\");

_LIT( KSlashData,                 "\\Data\\");

_LIT( KUnknown,                   "Unknown");

_LIT( KSeparator,                 ":" );

_LIT( KNullTime,                  "000000" );

_LIT8( KMimeAudio,                "audio" );

_LIT8( KMimeVideo,                "video" );

_LIT8( KMimeImage,                "image" );

_LIT8( KMimePlaylist,             "audio/mpegurl" );

#if defined(__HN_31__) || defined(__HN_32__)

const TUid KHnCRUidMediaServer = { 0x2000f87f }; //for parallel stack

#else

const TUid KCRUidMediaServer   = { 0x101F978F };

#endif

const TInt KDateStringLength        = 10;

const TInt KDateTimeStringLength    = 19;

const TInt KMaxDateStringLength     = 30;

// ============================ MEMBER FUNCTIONS ============================

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

// CUPnPMSPathUtility::CUPnPMSPathUtility

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUPnPMSPathUtility::CUPnPMSPathUtility()

    {

    }

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

// CUPnPMSPathUtility::NewL

// Two-phased constructor.

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

//

CUPnPMSPathUtility* CUPnPMSPathUtility::NewL()

    {

    CUPnPMSPathUtility* self = CUPnPMSPathUtility::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CUPnPMSPathUtility::NewLC

// Two-phased constructor.

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

//

CUPnPMSPathUtility* CUPnPMSPathUtility::NewLC()

    {

    CUPnPMSPathUtility* self = new( ELeave ) CUPnPMSPathUtility;

    CleanupStack::PushL( self );

    #if defined(__HN_31__) || defined(__HN_32__)

    self->ConstructL( KHnCRUidMediaServer );

    #else

    self->ConstructL( KCRUidMediaServer );

    #endif    

    return self;

    }

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

// CUPnPMSPathUtility::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUPnPMSPathUtility::ConstructL(TUid aRepositoryUid)

    {

    iRepository = CRepository::NewL(aRepositoryUid);

    }

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

// CUPnPMSPathUtility::~CUPnPMSPathUtility()

// Destructor

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

//

CUPnPMSPathUtility::~CUPnPMSPathUtility()

    {

    delete iRepository;

    }

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

// CUPnPMSPathUtility::GetCopyPathDriveL

// Gets the drive for the copy operation

// (other items were commented in a header).

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

//

void CUPnPMSPathUtility::GetCopyPathDriveL( 

             TDriveNumber& aDrive ) const

    {

    HBufC* location = HBufC::NewL(KMaxFileName);

    CleanupStack::PushL( location );

    TPtr locPtr = location->Des();

    // Get the location setting from ServerSettings

    iRepository->Get( EUploadDirectory, locPtr );

    // Check to see if drive is ready.

    TVolumeInfo volInfo;

    TDriveUnit driveUnit = TDriveUnit( locPtr );

    RFs fileServer;

    User::LeaveIfError( fileServer.Connect() );

    CleanupClosePushL( fileServer );

    User::LeaveIfError( fileServer.Volume( volInfo, driveUnit ) );

    CleanupStack::PopAndDestroy( &fileServer );

    aDrive = (TDriveNumber)((TInt)driveUnit);

    CleanupStack::PopAndDestroy( location );

    }

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

// CUPnPMSPathUtility::GetCopyPathL

// Returns the path of the upnp item to be copied

// (other items were commented in a header).

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

//

HBufC* CUPnPMSPathUtility::GetCopyPathL(

                        const TXmlEngElement& aItem,

                        CUpnpDlnaProtocolInfo& aProInfo ) const

    {

    TDriveNumber drive;

    GetCopyPathDriveL( drive );   

    return GetCreateCopyPathL( aItem, 

                               aProInfo, 

                               EFalse,

                               drive );

    }   

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

// CUPnPMSPathUtility::CreateCopyPathL

// Returns the path of the upnp item to be copied

// Creates the path if necessary and appends the filename and extension if

// required

// (other items were commented in a header).

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

//

HBufC* CUPnPMSPathUtility::CreateCopyPathL(

                const TXmlEngElement& aItem,

                CUpnpDlnaProtocolInfo& aProInfo ) const

    {

    TDriveNumber drive;

    GetCopyPathDriveL( drive );

    return GetCreateCopyPathL( aItem, 

                               aProInfo, 

                               ETrue,

                               drive );

    }

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

// CUPnPMSPathUtility::GetCreateCopyPathL

// Returns the path of the upnp item to be copied

// Creates the path if necessary and appends the filename and extension if

// required

// (other items were commented in a header).

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

//

HBufC* CUPnPMSPathUtility::GetCreateCopyPathL(

               const TXmlEngElement& aItem,

               CUpnpDlnaProtocolInfo& aProInfo,

               TBool aCreatePath,

               TDriveNumber aDriveNumber ) const

    {

    HBufC* path = HBufC::NewLC( KMaxPath );

    TPtr refPath = path->Des();

    TDriveUnit driveUnit = TDriveUnit( aDriveNumber );

    AppendDataL( refPath, driveUnit.Name() );

    if ( EDriveC == driveUnit )

        {

        //C:\\Data\\(Images/Videos/Sounds)....

        AppendDataL( refPath, KSlashData );

        }

    else

        {

        //\\(Images/Videos/Sounds)....

        AppendDataL( refPath, KBackSlash );

        }

    // Get the protocolinfo-attribute

    TUPnPItemType fileType = FileTypeByMimeTypeL( 

            aProInfo.ThirdField() );

    switch( fileType )

        {

        case ETypeAudio:

            {

            AppendDataL( refPath, PathInfo::SoundsPath() );

            AppendArtistAlbumL( refPath, aItem );

            break;

            }

        case ETypeVideo:

            {

            AppendDataL( refPath, PathInfo::VideosPath() );

            AppendYearMonthDayL( refPath, aItem );

            break;

            }

        case ETypeImage:

            {

            AppendDataL( refPath, PathInfo::ImagesPath() );

            AppendYearMonthDayL( refPath, aItem );

            break;

            }

        case ETypePlaylist:

        case ETypeOther:

        default:

            {

            AppendDataL( refPath, PathInfo::OthersPath() );

            }                

        }

    if( aCreatePath )

        {

        RFs fs;

        User::LeaveIfError( fs.Connect() );

        CleanupClosePushL(fs);

        BaflUtils::EnsurePathExistsL( fs, refPath );

        CleanupStack::PopAndDestroy(&fs);

        }

    CleanupStack::Pop( path );

    return path;

    }   

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

// CUPnPMSPathUtility::FileTypeByMimeTypeL

// Get the file type based on MIME type of the file. Leaves in error cases.

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

CUPnPMSPathUtility::TUPnPItemType CUPnPMSPathUtility::FileTypeByMimeTypeL(

        const TDesC8& aMimeType ) const

    {

    TUPnPItemType returnValue = ETypeOther;

    if( aMimeType != KNullDesC8 )

        {

        if( aMimeType.Find( KMimeImage() ) >= 0 )

            {

            returnValue = ETypeImage;

            }

        else if( aMimeType.Find( KMimePlaylist() ) >= 0 )

            {

            returnValue = ETypePlaylist;

            }

        else if( aMimeType.Find( KMimeAudio() ) >= 0 )

            {

            returnValue = ETypeAudio;

            }

        else if( aMimeType.Find( KMimeVideo() ) >= 0 )

            {

            returnValue = ETypeVideo;

            }

        else

            {

            returnValue = ETypeOther;

            }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return returnValue;

    }

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

// CUPnPMSPathUtility::AppendYearMonthDayL

// Appends year, month and day to the path.

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

//

void CUPnPMSPathUtility::AppendYearMonthDayL( 

        TDes& aPath, const TXmlEngElement& aItem ) const

    {  

    // Get the date-element

    TXmlEngElement dateElem;

    UpnpDomInterface::GetElementL( aItem, dateElem, KDate8 );

    TTime date; date.HomeTime();

    TInt offsetMonthDay = 1;

    // Use date element time instead of current time,

    // if element exist

    if ( !dateElem.IsNull() )

        {

        UPnPDateAsTTimeL( dateElem.Value(), date );

        offsetMonthDay = 0;

        }

    TDateTime ymd = date.DateTime();

    CheckBufferSpaceL( aPath, 11 ); //4(year)+2(month)+2(day)+3(\)

    aPath.AppendFormat( KYearMonthDayFormat(), 

            ymd.Year(), 

            ymd.Month() + offsetMonthDay, 

            ymd.Day() + offsetMonthDay );

    }

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

// CUPnPMSPathUtility::AppendArtistAlbumL

// Appends artist and album to the path.

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

//

void CUPnPMSPathUtility::AppendArtistAlbumL( 

        TDes& aPath, const TXmlEngElement& aItem ) const

    {

    // Get the artist-element

    TXmlEngElement artistElem;

    UpnpDomInterface::GetElementL( aItem, artistElem, KArtist );

    if ( !artistElem.IsNull( )  )

        {

        HBufC* artist = UpnpString::ToUnicodeL( artistElem.Value() );

        CleanupStack::PushL( artist );

        TPtr ptrArtist = artist->Des();

        UpnpCdUtils::ValidateFilePath( ptrArtist );

        CheckBufferSpaceL( aPath, artist->Length()+1 );// 1 for '\'          

        aPath.AppendFormat( KArtistFormat(), artist );

        CleanupStack::PopAndDestroy( artist );

        }

    else

        {

        CheckBufferSpaceL( aPath, KUnknown().Length()+1 );  // 1 for '\'       

        aPath.AppendFormat( KArtistFormat(), &KUnknown() );

        }

    // Get the album-element

    TXmlEngElement albumElem;

    UpnpDomInterface::GetElementL( aItem, albumElem, KAlbum );

    if ( !albumElem.IsNull( ) )

        {

        HBufC* album = UpnpString::ToUnicodeL( albumElem.Value() );

        CleanupStack::PushL( album );

        TPtr ptrAlbum = album->Des();

        UpnpCdUtils::ValidateFilePath( ptrAlbum );

        CheckBufferSpaceL( aPath, album->Length()+1 );// 1 for '\'

        aPath.AppendFormat( KAlbumFormat(), album );

        CleanupStack::PopAndDestroy( album );

        }

    else

        {

        CheckBufferSpaceL( aPath, KUnknown().Length()+1 );  // 1 for '\'       

        aPath.AppendFormat( KAlbumFormat(), &KUnknown() );

        }

    }

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

// CUPnPMSPathUtility::AppendDataL

// Appends data to the path's buffer.

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

//

void CUPnPMSPathUtility::AppendDataL( 

        TDes& aPath, const TDesC& aData ) const

    {  

    CheckBufferSpaceL( aPath, aData );

    aPath.Append( aData );

    }

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

// CUPnPMSPathUtility::CheckBufferSpaceL

// Checks whether the data can be appended to buffer or not.

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

//

void CUPnPMSPathUtility::CheckBufferSpaceL( 

        const TDes& aPath, const TDesC& aData ) const

    {

    CheckBufferSpaceL( aPath, aData.Length() );

    }

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

// CUPnPMSPathUtility::CheckBufferSpaceL

// Checks whether the data of the specified length

// can be appended to buffer or not.

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

//

void CUPnPMSPathUtility::CheckBufferSpaceL( 

        const TDes& aPath, const TInt& aLength ) const

    {  

    if ( (aPath.Length() + aLength) > aPath.MaxLength() )

        {

        User::Leave( KErrOverflow );

        }

    }

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

// CUPnPMSPathUtility::UPnPDateAsTTimeL

// Converts upnp date to TTime object.

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

void CUPnPMSPathUtility::UPnPDateAsTTimeL( const TDesC8& aUpnpDate,

    TTime& aTime ) const

    {

    // This method is capable of handling the most common dc:date formats:

    // CCYY-MM-DD and CCYY-MM-DDThh:mm:ss

    // Rest of the dc:date formats are handled as well, but they might not

    // be converted precisely

    TBuf<KMaxDateStringLength> formatDateString;

    HBufC* dateString = HBufC::NewL( aUpnpDate.Length() );

    dateString->Des().Copy( aUpnpDate );

    if( aUpnpDate.Length() >= KDateStringLength )

        {

        // CCYY-MM-DD --> CCYYMMDD

        formatDateString.Copy( dateString->Des().Left( 4 ) ); // Year

        formatDateString.Append( dateString->Des().Mid( 5,2 ) ); // Month

        formatDateString.Append( dateString->Des().Mid( 8,2 ) ); // Day        

        if( aUpnpDate.Length() >= KDateTimeStringLength )

            {

            // hh:mm:ss --> hhmmss

            formatDateString.Append( KSeparator );

            // Hours

            formatDateString.Append( dateString->Des().Mid( 11, 2 ) ); 

            // Minutes

            formatDateString.Append( dateString->Des().Mid( 14, 2 ) );

            // Seconds 

            formatDateString.Append( dateString->Des().Mid( 17, 2 ) ); 

            }

        else

            {

            // hh:mm:ss --> 000000

            formatDateString.Append( KSeparator );

            formatDateString.Append( KNullTime );

            }

        }

    delete dateString;

    User::LeaveIfError( aTime.Set( formatDateString ) );

    }

//  End of File