/*

 * Copyright (c) 2008-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:    CGlxImageViewerManager implementation

 *

 */

#include "glximageviewermanager.h"

#include <glxsingletonstore.h>

#include <glxtracer.h>

#include <glxlog.h>

#include <f32file.h>

#include <caf/manager.h>

#include <caf/content.h>

#include <driveinfo.h>

#include <coeutils.h>

#include <coemain.h>

_LIT( KPrivateFolder, "\\Private\\" );

_LIT( KGifFileMime, "image/gif" );

_LIT( KMbmFileExt, "image/x-epoc-mbm");

_LIT( KTempFilePath, "?:\\data\\images\\" );

EXPORT_C CGlxImageViewerManager* CGlxImageViewerManager::InstanceL()

    {

    TRACER("CGlxImageViewerManager::InstanceL()");

    return CGlxSingletonStore::InstanceL(&NewL);

    }

EXPORT_C void CGlxImageViewerManager::DeleteInstance()

    {

    TRACER("CGlxImageViewerManager::DeleteInstance()");

    CGlxSingletonStore::Close(this);

    }

EXPORT_C HBufC* CGlxImageViewerManager::ImageUri()

    {

    TRACER("CGlxImageViewerManager::ImageUri()");    

    return iImageUri;

    }

EXPORT_C RFile64& CGlxImageViewerManager::ImageFileHandle()

    {

    TRACER("CGlxImageViewerManager::ImageFileHandle()");    

    return *iFile;

    }

EXPORT_C TBool CGlxImageViewerManager::IsPrivate()

    {

    TRACER("CGlxImageViewerManager::IsPrivate()");    

    return iIsPrivate;

    }

EXPORT_C TBool CGlxImageViewerManager::IsPrivateGif()

    {

    TRACER("CGlxImageViewerManager::IsPrivateGif()");    

    return iIsPrivateGif;

    }

CGlxImageViewerManager::CGlxImageViewerManager()

    : iImageUri(NULL), iFile(NULL), iIsPrivate(EFalse)

    {

    TRACER("CGlxImageViewerManager::CGlxImageViewerManager()");

    // No implementation required

    }

CGlxImageViewerManager::~CGlxImageViewerManager()

    {

    TRACER("CGlxImageViewerManager::~CGlxImageViewerManager()");

    Reset();

    }

CGlxImageViewerManager* CGlxImageViewerManager::NewLC()

    {

    TRACER("CGlxImageViewerManager::NewLC()");

    CGlxImageViewerManager* self = new (ELeave) CGlxImageViewerManager();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CGlxImageViewerManager* CGlxImageViewerManager::NewL()

    {

    TRACER("CGlxImageViewerManager::NewL()");

    CGlxImageViewerManager* self = CGlxImageViewerManager::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

void CGlxImageViewerManager::ConstructL()

    {

    TRACER("CGlxImageViewerManager::ConstructL()");

    }

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

// SetImageUri

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

//

EXPORT_C void CGlxImageViewerManager::SetImageUriL(const TDesC& aFileName)

    {

    TRACER("void CGlxImageViewerManager::SetImageUriL()");    

    GLX_LOG_URI("CGlxImageViewerManager::SetImageUriL(%S)", &aFileName);

    if ( iImageUri )

        {

        delete iImageUri;

        iImageUri = NULL;

        }

    if (aFileName.Length() == 0)

        {

        User::Leave(KErrNotSupported);    

        }

    iImageUri = aFileName.AllocL();  

    CreateImageDecoderL();

    }

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

// Reset

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

//

EXPORT_C void CGlxImageViewerManager::Reset()

    {

    TRACER("void CGlxImageViewerManager::Reset()");

    if( iFile )

        {

        iFile->Close();

        }

    delete iFile;

    iFile = NULL;

	CloseImageDecoder();

    if (iIsPrivateGif)

        {

        iManager->DeleteFile(iImageUri->Des());

        iIsPrivateGif = EFalse;

        }

    if ( iManager )

        {

        delete iManager;

        iManager = NULL;

        }

    if ( iImageUri )

        {

        delete iImageUri;

        iImageUri = NULL;

        }

    iIsPrivate = EFalse;

    }

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

// SetImageFileHandleL

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

//

EXPORT_C void CGlxImageViewerManager::SetImageFileHandleL(const RFile& aFileHandle)

    {

    TRACER("void CGlxImageViewerManager::SetImageFileHandleL()");

    TFileName filePath;

    User::LeaveIfError(aFileHandle.FullName(filePath));

    TParsePtrC parse(filePath);

    if (parse.PathPresent() && parse.Path().Length()

            > KPrivateFolder().Length() && parse.Path().Left(

            KPrivateFolder().Length()).CompareF(KPrivateFolder) == 0)

        {

        // File is in private folder; duplicate file handle

        iFile = new (ELeave) RFile64;

        User::LeaveIfError(iFile->Duplicate(aFileHandle));

        iIsPrivate = ETrue;

        // Better to use contentaccess as we need to deal with DRM files

        TBuf<KMaxName> mimeBuf;

        ContentAccess::CContent* content = ContentAccess::CContent::NewLC(

                *iFile);

        TInt err(content->GetStringAttribute(ContentAccess::EMimeType,

                mimeBuf));

        CleanupStack::PopAndDestroy(content);

        // Gif / MBM file from private path, hence make a local copy.

        if (mimeBuf.Compare(KGifFileMime) == 0

                || mimeBuf.Compare(KMbmFileExt) == 0)

            {

            TFileName ramFilePath;

            ramFilePath.Copy(KTempFilePath);

            ramFilePath.Append(parse.NameAndExt());

            TChar drive;

            User::LeaveIfError(DriveInfo::GetDefaultDrive(

                    DriveInfo::EDefaultRam, drive));

            ramFilePath[0] = drive;

            ConeUtils::EnsurePathExistsL(ramFilePath);

            if (!iManager)

                {

                iManager = ContentAccess::CManager::NewL();

                }

            iManager->CopyFile(*iFile, ramFilePath);

            filePath.Copy(ramFilePath);

            iIsPrivateGif = ETrue;

            }

        }

    SetImageUriL( filePath );

    }

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

// CloseImageDecoder

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

//

EXPORT_C void CGlxImageViewerManager::CloseImageDecoder()

    {

    TRACER("void CGlxImageViewerManager::CloseImageDecoder()");

    if (iImageDecoder)

        {

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    }

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

// CreateImageDecoderL

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

//

EXPORT_C void CGlxImageViewerManager::CreateImageDecoderL()

    {

    TRACER("void CGlxImageViewerManager::CreateImageDecoderL()");

    CloseImageDecoder();

    TInt err = KErrNone;

    if (IsPrivate())

        {

        if (&ImageFileHandle())

            {

            GLX_DEBUG1("CGlxImageViewerManager::CreateImageDecoderL() FH");

            TRAP(err, iImageDecoder = CImageDecoder::FileNewL(

                    ImageFileHandle(), ContentAccess::EPeek));

            }

        }

    else

        {

        if (ImageUri())

            {

            GLX_DEBUG1("CGlxImageViewerManager::CreateImageDecoderL() FN");

            TRAP(err, iImageDecoder = CImageDecoder::FileNewL(

                    CCoeEnv::Static()->FsSession(), ImageUri()->Des()));

            }

        }

    GLX_DEBUG2("CGlxImageViewerManager::CreateImageDecoderL() err(%d)", err);

    User::LeaveIfError(err);

    }