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

//  Include Files  

#include <f32file.h>
#include <mdeproperty.h>
#include <mdeinstanceitem.h>
#include <mdeitem.h>
#include <mdesession.h>
#include <fbs.h>
#include <thumbnaildata.h>
#include <ImageConversion.h>
#include "upnpthumbnailcreator.h"  // CUpnpThumbnailCreator
#include "upnpthumbnailcreatorObserver.h"
#include "upnpfileutilitytypes.h"

_LIT( KComponentLogfile, "upnpthumbnailcreator.txt");
_LIT(KSystemFilePath, "c:\\system\\temp\\");
#include "upnplog.h"

const TInt KSmallWidth = 640;
const TInt KSmallHeight = 480;
const TInt KMediumWidth = 1024;
const TInt KMediumHeight = 768;
const TInt KLargeWidth = 4096;
const TInt KLargeHeight = 4096;
const TInt KThumbnailWidth = 160;
const TInt KThumbnailHeight = 160;
const TInt KSmallIconWidth = 48;
const TInt KSmallIconHeight = 48;
const TInt KLargeIconWidth = 160;
const TInt KLargeIconHeight = 160;
//  Member Functions


// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::NewLC
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
EXPORT_C CUpnpThumbnailCreator* CUpnpThumbnailCreator::NewLC(
        MUpnpThumbnailCreatorObserver& aMUpnpThumbnailCreatorObserver,
        const TDesC& aFilePath,
        TThumbnailDlnaSize aSize)
    {
    CUpnpThumbnailCreator* self = new (ELeave) CUpnpThumbnailCreator(
            aMUpnpThumbnailCreatorObserver, aSize);
    CleanupStack::PushL(self);
    self->ConstructL(aFilePath);
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::NewL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
EXPORT_C CUpnpThumbnailCreator* CUpnpThumbnailCreator::NewL(
        MUpnpThumbnailCreatorObserver& aMUpnpThumbnailCreatorObserver,
        const TDesC& aFilePath,
        TThumbnailDlnaSize aSize)
    {
    __LOG1( "CUpnpThumbnailCreator:NewL() aFilePath: &s", &aFilePath);    
    CUpnpThumbnailCreator* self = CUpnpThumbnailCreator::NewLC(
            aMUpnpThumbnailCreatorObserver,aFilePath, aSize);
    CleanupStack::Pop(self);
    return self;
    }



// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::MdeObjectId
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
EXPORT_C TInt CUpnpThumbnailCreator::MdeObjectId() const
    {
    return iObjectid;
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::ThumbnailFilePath
// See upnpthumbnailcreator.h // CI: RM return TDesC &
//---------------------------------------------------------------------------
EXPORT_C const TDesC& CUpnpThumbnailCreator::ThumbnailFilePath() const
    {
    __ASSERT( iThumbnailFilePath, __FILE__, __LINE__ );
    return *iThumbnailFilePath;
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::Thumbnail
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
EXPORT_C CFbsBitmap& CUpnpThumbnailCreator::Thumbnail() const
    {
    __ASSERT( iThumbnail, __FILE__, __LINE__ );
    return *iThumbnail;
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::~CUpnpThumbnailCreator
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
CUpnpThumbnailCreator::~CUpnpThumbnailCreator()
    {
    __LOG( "CUpnpThumbnailCreator:~CUpnpThumbnailCreator()");
    if (IsActive())
        {
        Cancel();
        }
    
    delete iImageFilePath;
    delete iMdEQuery;
    delete iMdESession;
    delete iThumbnail; 
    delete iThmbManager;
    delete iImageEncoder;
	
    if(iThumbnailFilePath != NULL)
        {
        iFsSession.Delete(iThumbnailFilePath->Des());
        delete iThumbnailFilePath;
        }
    iFsSession.Close();
    
    }
 

/********************************************************************
 * MMdESessionObserver  virtual methods
 ********************************************************************/ 

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::HandleSessionOpened
// See mdesession.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::HandleSessionOpened(CMdESession& /*aSession*/, 
                                                            TInt aError)
    {
    __LOG1( "CUpnpThumbnailCreator:HandleSessionOpened() %d", aError);
    CompleteRequest(aError);
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::HandleSessionError
// See mdesession.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::HandleSessionError(CMdESession& /*aSession*/, 
                                                            TInt aError)
    {
     __LOG1( "CUpnpThumbnailCreator:HandleSessionError() %d", aError);
     CompleteRequest(aError);
    }
/********************************************************************
 * MMdEQueryObserver virtual methods
 ********************************************************************/

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::HandleQueryNewResults
// See mdequery.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::HandleQueryNewResults(CMdEQuery& aQuery, 
                                                TInt aFirstNewItemIndex,
                                                TInt aNewItemCount)
    {
    CMdEObjectQuery& query = (CMdEObjectQuery &) aQuery;
    if (aNewItemCount > 0)
        {
        TInt i( aFirstNewItemIndex);
        for ( ; i < (aFirstNewItemIndex+aNewItemCount); i++)
            {
            CMdEObject* object = (CMdEObject*)query.TakeOwnershipOfResult(i);
            if(object->Uri().CompareF(iImageFilePath->Des()) == 0)
                {
                iObjectid = object->Id();
                CompleteRequest(KErrNone);
                break;
                }
            delete object;
            }
        if(i == (aFirstNewItemIndex + aNewItemCount))
            {
            CompleteRequest(KErrNotFound);
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::HandleQueryCompleted
// See mdequery.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::HandleQueryCompleted(CMdEQuery& /*aQuery*/, 
                                                                TInt aError)
    {
     __LOG1( "CUpnpThumbnailCreator:HandleQueryCompleted() %d",aError);
     if(aError != KErrNone)
         {
         CompleteRequest(aError);
         }     
    }

/********************************************************************
 * MThumbnailManagerObserver virtual methods
 ********************************************************************/

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::ThumbnailPreviewReady
// See thumbnailmanagerobserver.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::ThumbnailPreviewReady(MThumbnailData& /*aThumbnail*/,
                                                TThumbnailRequestId /*aId*/ )
    {    
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::ThumbnailReady
// See thumbnailmanagerobserver.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::ThumbnailReady(TInt aError, 
                                            MThumbnailData& aThumbnail, 
                                            TThumbnailRequestId /*aId*/ )
    {
    // This function must not leave.
     __LOG1( "CUpnpThumbnailCreator:ThumbnailReady() %d",aError);
    delete iThumbnail; iThumbnail = NULL;
    if ( aError == KErrNone )
        {
        // Claim ownership of the bitmap instance for later use
        iThumbnail = aThumbnail.DetachBitmap();
        }
    
    CompleteRequest(aError);
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::NotifyCompletion
// See upnpbitmapconverterobserver.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::ThumbnailReady(TInt aError)
    {
    if(iThumbnailFilePath)
        {
        TInt ret = iFsSession.SetAtt(iThumbnailFilePath->Des(),KEntryAttHidden,KEntryAttArchive); 
        __LOG1( "CUpnpThumbnailCreator:NotifyCompletion - thumbnail attribute hidden result %d",ret);
        }
    iMUpnpThumbnailCreatorObserver.ThumbnailCreatorReady(aError);    
    }


// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::CUpnpThumbnailCreator
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
CUpnpThumbnailCreator::CUpnpThumbnailCreator(
        MUpnpThumbnailCreatorObserver& aMUpnpThumbnailCreatorObserver,
        TThumbnailDlnaSize aSize)
        :CActive( CActive::EPriorityStandard ),
        iMUpnpThumbnailCreatorObserver(aMUpnpThumbnailCreatorObserver),
        iThumbnailDlnaSize (aSize)
        
    {
    CActiveScheduler::Add( this );
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::ConstructL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------        
void CUpnpThumbnailCreator::ConstructL(const TDesC& aFilePath)
    {
    // second phase constructor, anything that may leave must be constructed here
    __LOG( "CUpnpThumbnailCreator:ConstructL() ");
    iState = EIdle;
    User::LeaveIfError(iFsSession.Connect());
    iImageFilePath = aFilePath.AllocL();
    
    ConvertDlnaSizeToImageSize();
    
    iThmbManager = CThumbnailManager::NewL( *this );
        
    // Set flags: Keep aspect ratio and allow smaller image than requested
    iThmbManager->SetFlagsL(static_cast<CThumbnailManager::TThumbnailFlags>(
    CThumbnailManager::EDefaultFlags | CThumbnailManager::EAllowAnySize )); 

    // Preferred size is 160x120 (or less)
    iThmbManager->SetThumbnailSizeL( ConvertDlnaSizeToImageSize() );
    
    iState = EInitializeMde;
    iMdESession = CMdESession::NewL(*this);
    
    iStatus = KRequestPending;
    SetActive();
    }

TSize CUpnpThumbnailCreator::ConvertDlnaSizeToImageSize()
    {
    TSize thumbnailSize;
    
    switch (iThumbnailDlnaSize)
        {
        case ESmall:
            {
            thumbnailSize = TSize (KSmallWidth, KSmallHeight);
            break;
            }
        case EMedium:
            {
            thumbnailSize = TSize (KMediumWidth, KMediumHeight);
            break;
            }
        case ELarge:
            {
            thumbnailSize = TSize (KLargeWidth, KLargeHeight);
            break;
            }
        case EThumbnail:
            {
            thumbnailSize = TSize (KThumbnailWidth, KThumbnailHeight);
            break;
            }
        case ESmallIcon:
            {
            thumbnailSize = TSize (KSmallIconWidth, KSmallIconHeight);
            break;
            }
        case ELargeIcon:
            {
            thumbnailSize = TSize (KLargeIconWidth, KLargeIconHeight);
            break;
            }
        default:
            {
            __LOG( "CUpnpThumbnailCreator::ConvertDlnaSizeToImageSize - Not Expected!" );
            __PANIC( __FILE__, __LINE__ );
            break;
            }
        }
    
    return thumbnailSize;
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::QueryMdeL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::QueryMdeL()
    {
     __LOG( "CUpnpThumbnailCreator:QueryMdeL() ");
    User::LeaveIfNull(iMdESession); //CI: LeaveIfNull() leaves with KErrNoMemory is this the idea? or can this even happen??
    
    CMdENamespaceDef& namespacedef = iMdESession->GetDefaultNamespaceDefL();
    CMdEObjectDef& objectdef = namespacedef.GetObjectDefL(
                                    MdeConstants::Image::KImageObject);
    iMdEQuery = iMdESession->NewObjectQueryL(namespacedef, objectdef, this);

    iMdEQuery->SetResultMode(EQueryResultModeItem);
    
    iMdEQuery->FindL();
    
    iStatus = KRequestPending;
    SetActive();
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::ParseImageMediaObjectL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------

void CUpnpThumbnailCreator::GetThumbnail()
    {
     __LOG( "CUpnpThumbnailCreator:GetThumbnail() ");
    // object id is available for the image,
    // thumbnail manager can give us the thumbnail.
    iThmbManager->GetThumbnailL(iObjectid);
    
    iStatus = KRequestPending;
    SetActive();
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::PrepareThumbnailFilePathL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::PrepareThumbnailFilePathL()
    {
     __LOG( "CUpnpThumbnailCreator:PrepareThumbnailFilePathL() ");
    TFileName path(KSystemFilePath);    
    //User::LeaveIfError(iFsSession.SessionPath(path));
    TInt ret = iFsSession.MkDir(path);
    //handle when creation of the path fails.
    if(ret == KErrNone || ret == KErrAlreadyExists )
        {
        TParse p;
        p.Set(iImageFilePath->Des(),NULL,NULL);
        TFileName filenameandext(p.NameAndExt());
        path.Append(filenameandext);
        iThumbnailFilePath = path.AllocL();
        }
    else
        {
        User::Leave(ret);
        }
    }

// --------------------------------------------------------------------------
// CUpnpThumbnailCreator::SaveThumbnailL
// See upnpthumbnailcreator.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::EncodeAndSaveThumbnailL()
    {
     __LOG( "CUpnpThumbnailCreator:SaveThumbnailL() ");
     PrepareThumbnailFilePathL();
     
     iImageEncoder = CImageEncoder::FileNewL(iFsSession,*iThumbnailFilePath,
             CImageEncoder::EOptionNone, KImageTypeJPGUid,KNullUid );

     iImageEncoder->Convert( &iStatus, *iThumbnail );
     SetActive();     
    }

void CUpnpThumbnailCreator::CompleteRequest(TInt aError)
    {
    TRequestStatus* stat = &iStatus;
    User::RequestComplete( stat, aError );
    }


// --------------------------------------------------------------------------
// CUpnpBitmapConverter::RunL
// See upnpbitmapconverter.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::RunL()
    {
    __LOG1( "CUpnpThumbnailCreator:RunL() iStatus=%d", iStatus.Int());
    
    if (iStatus.Int() < 0)
        {
        ThumbnailReady(iStatus.Int());
        }
    else
        {
        switch (iState)
            {
            case EIdle:
                {
                break;
                }
            case EInitializeMde:
                {
                iState = EQueryingImage;
                QueryMdeL();
                break;
                }
            case EQueryingImage:
                {
                iState = EFetchingThumbnail;
                GetThumbnail();
                break;
                }
            case EFetchingThumbnail:
                {
                iState = EConvertingThumbnail;
                EncodeAndSaveThumbnailL();
                break;
                }
            case EConvertingThumbnail:
                {
                ThumbnailReady(iStatus.Int());             
                break;
                }
            }
        }
    }

TInt CUpnpThumbnailCreator::RunError( TInt aError )
    {
    iState = EIdle;
    ThumbnailReady(aError);
    return KErrNone;
    }


// --------------------------------------------------------------------------
// CUpnpBitmapConverter::DoCancel
// See upnpbitmapconverter.h
//---------------------------------------------------------------------------
void CUpnpThumbnailCreator::DoCancel()
    {
    __LOG( "CUpnpThumbnailCreator:DoCancel()");
    if (iState == EConvertingThumbnail)
        {
        iImageEncoder->Cancel();
        }
    else
        {
        TRequestStatus* stat = &iStatus;
        User::RequestComplete( stat, KErrCancel );        
        }
    }