/*

* Copyright (c) 2009 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:      Resolver for local items

*

*/

// INCLUDE FILES

// dlnasrv / mediaserver api

#include <upnpitem.h>

// mpx

#include <mpxmedia.h>

#include <mpxmediamusicdefs.h>

#include <mpxcollectionhelper.h>

#include <mpxcollectionhelperfactory.h>

// dlnasrv / avcontroller api

#include "upnpavcontroller.h" // avcontroller service

#include "upnpavbrowsingsession.h" // browsing session

#include "upnpavdevice.h" // device (for creating a session)

// dlnasrv / avcontroller helper api

#include "upnpitemresolverfactory.h" // optimisation flags

#include "upnpitemresolverobserver.h" // MUPnPItemResolverObserver

#include "upnpfileutility.h" // IsFileProtected

#include "upnpresourceselector.h" // MUPnPResourceSelector

#include "upnpitemutility.h" // GetResElements

#include "upnpconstantdefs.h" // for upnp-specific stuff

// dlnasrv / internal api

#include "upnppushserver.h" // CUpnpPushServer

#include "upnpmetadatafetcher.h" // CreateItemFromFileLC

#include "upnpstring.h"

// dlnasrv / avcontrollerhelper internal

#include "upnplocalitemresolver.h"

#include "upnptranscodehelper.h"

#include "upnpcdsreselementutility.h"

#include "upnpdlnaprofiler.h"

_LIT( KComponentLogfile, "upnpavcontrollerhelper.txt");

#include "upnplog.h"

// CONSTANTS

static TUint KFirstSharedHash = 8647544;

// METHODS

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

// CUPnPLocalItemResolver:: NewL

// See upnplocalitemresolver.h

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

CUPnPLocalItemResolver* CUPnPLocalItemResolver::NewL(

    const TDesC& aFilePath,

    MUPnPAVController& aAvController,

    MUPnPResourceSelector& aSelector,

    TInt aOptimisationFlags    )

    {

    CUPnPLocalItemResolver* self = new (ELeave )CUPnPLocalItemResolver(

								aAvController, aSelector, aOptimisationFlags );

    CleanupStack::PushL( self );

    self->ConstructL( aFilePath );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPLocalItemResolver::CUPnPLocalItemResolver

// See upnplocalitemresolver.h

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

CUPnPLocalItemResolver::CUPnPLocalItemResolver(

    MUPnPAVController& /*aAvController*/,

    MUPnPResourceSelector& aSelector,

    TInt aOptimisationFlags )

    : iSelector( aSelector )

    {

    iOptimisationFlags = aOptimisationFlags;

    }

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

// CUPnPLocalItemResolver::ConstructL

// See upnplocalitemresolver.h

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

void CUPnPLocalItemResolver::ConstructL(

    const TDesC& aFilePath )

    {

    __LOG1( "LocalItemResolver:ConstructL() 0x%d", TInt(this) );

    iFilePath = aFilePath.AllocL();

#ifdef UPNP_USE_GSTREAMER

    iTranscodeHelper = CUpnpTranscodeHelper::NewL();

#endif

    // create mpx collection helper

    iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionHelperL();

    }

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

// CUPnPLocalItemResolver::~CUPnPLocalItemResolver

// See upnplocalitemresolver.h

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

CUPnPLocalItemResolver::~CUPnPLocalItemResolver()

    {

    __LOG1( "LocalItemResolver destructor 0x%d", TInt(this) );

    delete iFilePath;

    iFilePath = NULL;

    delete iSharedItem;

    iSharedItem = NULL;

    delete iThumbnailCreator;

    iThumbnailCreator = NULL;

    Cleanup();

#ifdef UPNP_USE_GSTREAMER

    delete iTranscodeHelper;

#endif

    iCollectionHelper->Close();

    __LOG( "LocalItemResolver destructor end" );

    }

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

// CUPnPLocalItemResolver::ResolveL

// See upnplocalitemresolver.h

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

void CUPnPLocalItemResolver::ResolveL(

    MUPnPItemResolverObserver& aObserver, CUpnpAVDevice* aDevice )

    {

    __LOG1( "LocalItemResolver:Resolve() 0x%d", TInt(this) );

    _LIT(KExtJpeg, ".jpeg");

    _LIT(KExtJpg,  ".jpg");

    iObserver = &aObserver;

    if ( !(iOptimisationFlags & UPnPItemResolverFactory::EOmitDrmCheck ))

        {

        // check DRM

        if ( UPnPFileUtility::IsFileProtectedL( iFilePath->Des() ) )

            {

            User::Leave( KErrNotSupported );

            }

        }

    // create item metadata

	delete iLocalItem;

	iLocalItem = NULL;

    iLocalItem =

		UPnPMetadataFetcher::CreateItemFromFileLC(

			iFilePath->Des());

    CleanupStack::Pop( iLocalItem );

#ifdef UPNP_USE_GSTREAMER

    if( aDevice )

        {

        HBufC8* pipeline = NULL;

        HBufC8* protocolInfo = NULL;

        TRAPD( err, iTranscodeHelper->PreDefinedCfgL( *aDevice, 

                *iLocalItem, pipeline, protocolInfo ) );

        __ASSERT_ALWAYS( err == KErrNone || err == KErrNotFound, 

                User::Invariant() );

        if( err == KErrNone )

            {

            CleanupStack::PushL(pipeline);

            CleanupStack::PushL(protocolInfo);

            //config found -> start transc and replace resource

            iTranscodeHelper->TranscodeL( *pipeline );

            iTranscodeHelper->ReplaceResourceL( *iLocalItem, *protocolInfo );

            CleanupStack::PopAndDestroy(protocolInfo);

            CleanupStack::PopAndDestroy(pipeline);

            }               

        }

#endif

    TParse p;

    p.Set(iFilePath->Des(),NULL,NULL);

    if( p.Ext().CompareF(KExtJpeg) == KErrNone 

        || p.Ext().CompareF(KExtJpg) == KErrNone )

        {

        //TThumbnailDlnaSize size (EThumbnail);

        //iThumbnailCreator = CUpnpThumbnailCreator::NewL(*this,

        //                                                *iFilePath, size);

        // TODO: the above code starts thumbnail creation,

        // but for some reason thumbnail manager returns with KErrBadName.

        // For now, just share the original, without creating a thumbnail res element

        ShareL();

        }

    else if( UPnPItemUtility::BelongsToClass(*iLocalItem,KClassAudio()) )

        {

        // 

        TRAPD( err, SetAlbumArtResourceToItemL( *iFilePath ) );

        __LOG1( "LocalItemResolver:Resolve() music album art err=%d",err );

        if( err )

            {

            // if song did not have album art share normally

            ShareL();

            }

        }

    else

        {

        ShareL();

        }

    __LOG( "LocalItemResolver:Resolve() END" );

    }

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

// CUPnPLocalItemResolver::ShareL

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

void CUPnPLocalItemResolver::ShareL()

    {

    // share

    CUpnpPushServer::ShareL( KFirstSharedHash++, *iLocalItem );

    // Store item & resource

    delete iSharedItem;

    iSharedItem = NULL;    

    iSharedItem = iLocalItem;

	iLocalItem = NULL;

    iResource = &iSelector.SelectResourceL( *iSharedItem );

    //inform the observer

    iObserver->ResolveComplete( *this, KErrNone );

    }

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

// CUPnPLocalItemResolver::Item

// See upnplocalitemresolver.h

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

const CUpnpItem& CUPnPLocalItemResolver::Item() const

    {

    __ASSERT( iSharedItem, __FILE__, __LINE__ );

    return *iSharedItem;

    }

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

// CUPnPLocalItemResolver::Resource

// See upnplocalitemresolver.h

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

const CUpnpElement& CUPnPLocalItemResolver::Resource() const

    {

    __ASSERT( iResource, __FILE__, __LINE__ );

    return *iResource;

    }

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

// CUPnPLocalItemResolver::Cleanup

// See upnplocalitemresolver.h

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

void CUPnPLocalItemResolver::Cleanup()

    {

    __LOG( "CUPnPLocalItemResolver:Cleanup() ");

    // unshare

    TRAP_IGNORE(CUpnpPushServer::UnshareL( (TUint)this ));

    __LOG( "CUPnPLocalItemResolver:Cleanup() end" );

    }

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

// CUPnPLocalItemResolver::SetAlbumArtResourceToItemL

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

//

void CUPnPLocalItemResolver::SetAlbumArtResourceToItemL( const TDesC& aFileName )

    {

    __LOG1( "CUPnPLocalItemResolver:SetAlbumArtResourceToItemL() fileName = %S",&aFileName);

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    attrs.AppendL( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) );

    CMPXMedia* media( NULL );

    media = iCollectionHelper->GetL( aFileName,

        attrs.Array(), EMPXSong );

    CleanupStack::PopAndDestroy( &attrs );

    CleanupStack::PushL( media );

    const TDesC& filePath = media->ValueText( KMPXMediaMusicAlbumArtFileName );

    TInt leaveErr(KErrNone);

    if( filePath != KNullDesC && filePath.CompareF(aFileName) != KErrNone )

        {

        __LOG( "CUPnPLocalItemResolver:SetAlbumArtResourceToItemL() \

                start waiting album art");

        TThumbnailDlnaSize size (EThumbnail);

        iThumbnailCreator = CUpnpThumbnailCreator::NewL(*this,

                filePath, size);

        }

    else

        {

        leaveErr = KErrNotFound;

        }

    CleanupStack::PopAndDestroy( media );

    if( leaveErr ) 

        {

        User::Leave(leaveErr);

        }

    }

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

// CUPnPLocalItemResolver::ThumbnailCreatorReady

// See upnplocalitemresolver.h

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

void CUPnPLocalItemResolver::ThumbnailCreatorReady( TInt aError)

    {

    __LOG1( "CUPnPLocalItemResolver:ThumbnailCreatorReady() %d",aError);

    if(aError == KErrNone)

    	{

        if( UPnPItemUtility::BelongsToClass(*iLocalItem,KClassAudio()) )

            {

            TRAPD(err, AddAlbumArtAndShareL())

            aError = err;

            }

        else

            {

            TRAPD(err,AddThumbnailandShareL());    

            aError = err;

            }

    	}

    //inform the observer

    iObserver->ResolveComplete( *this, aError );

    }

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

// CUPnPLocalItemResolver::AddAlbumArtAndShareL

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

void CUPnPLocalItemResolver::AddAlbumArtAndShareL()

    {

    __ASSERT( iLocalItem, __FILE__, __LINE__ );    

    __LOG( "CUPnPLocalItemResolver:AddAlbumArtAndShareL()");

    CUpnpElement* albumArtUri = CUpnpElement::NewLC( KElementAlbumArtUri );

    CUpnpAttribute* attr = CUpnpAttribute::NewLC( KAttributeProfileId() );

    CUpnpDlnaProfiler* profiler = CUpnpDlnaProfiler::NewLC();

    HBufC8* profile = NULL;

    profile = UpnpString::FromUnicodeL(*(profiler->ProfileForFileL( 

            iThumbnailCreator->ThumbnailFilePath())) ); 

    CleanupStack::PopAndDestroy( profiler );                  

    __LOG1( "CUPnPLocalItemResolver:AddAlbumArtAndShareL() \

            profile=%S",profile);

    attr->SetValueL(*profile);

    albumArtUri->AddAttributeL(attr);    

    CleanupStack::Pop( attr );                  

    albumArtUri->SetFilePathL( iThumbnailCreator->ThumbnailFilePath() );

    iLocalItem->AddElementL( albumArtUri );

    CleanupStack::Pop( albumArtUri );    

    // share

    CUpnpPushServer::ShareL( KFirstSharedHash++, *iLocalItem );	

    // Store item & resource

    delete iSharedItem;

    iSharedItem = NULL;

    iSharedItem = iLocalItem;

    iResource = &iSelector.SelectResourceL( *iSharedItem );

    }

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

// CUPnPLocalItemResolver::AddThumbnailandShareL

// See upnplocalitemresolver.h

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

void CUPnPLocalItemResolver::AddThumbnailandShareL()

    {

    __ASSERT( iLocalItem, __FILE__, __LINE__ );

    UpnpCdsResElementUtility::AddResElementL(*iLocalItem,

                                iThumbnailCreator->ThumbnailFilePath());

    // share

    CUpnpPushServer::ShareL( KFirstSharedHash++, *iLocalItem );

    // Store item & resource

    delete iSharedItem;

    iSharedItem = NULL;

    iSharedItem = iLocalItem;

    iResource = &iSelector.SelectResourceL( *iSharedItem );

    }